patriksimek/vm2Sandbox JavaScript isolato per Node.js che esegue codice non attendibile con accesso limitato ai moduli integrati e alle risorse host tramite intercettazione basata su Proxy.
[![Known Vulnerabilities][snyk-image]][snyk-url]vm2 è una sandbox che può eseguire codice non attendibile con i moduli integrati di Node consentiti.
npm install vm2
## Esempi rapidi```js
import { VM } from 'vm2';
const vm = new VM();
vm.run(`process.exit()`); // TypeError: process.exit is not a function
I'm ready to translate the Kitploit tool content from English to Italian. Please provide chunk 5 of 55.```js import { NodeVM } from 'vm2';
const vm = new NodeVM({ require: { external: true, root: './', }, });
vm.run(
var request = require('request'); request('http://www.google.com', function (error, response, body) { console.error(error); if (!error && response.statusCode == 200) { console.log(body); // Show the HTML for the Google homepage. } });,
'vm.js',
);
## Importante Dichiarazione di Sicurezza
**Prima di usare vm2, dovresti capire come funziona e quali sono i suoi limiti.**
vm2 tenta di isolare codice JavaScript non attendibile **all'interno dello stesso processo Node.js** della tua applicazione. Lo fa attraverso una complessa rete di [Proxy](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Proxy) che intercettano e mediano ogni interazione tra la sandbox e l'ambiente host.
### La Sfida Fondamentale
JavaScript è un linguaggio straordinariamente dinamico. Gli oggetti possono essere raggiunti tramite le catene di prototipi, i costruttori possono essere raggiunti tramite gli oggetti di errore, i simboli forniscono hook di protocollo e l'esecuzione asincrona crea finestre di temporizzazione. L'enorme numero di modi per passare da un oggetto all'altro in JavaScript rende estremamente difficile costruire una sandbox in-process a tenuta stagna.
**Siamo onesti su questa realtà:** Nonostante i nostri migliori sforzi, ricercatori e professionisti della sicurezza scoprono continuamente nuovi modi per evadere dalla sandbox di vm2. Correggiamo attivamente queste vulnerabilità man mano che vengono segnalate, ma la natura del gatto e del topo dell'isolamento in-process significa che:
1. **È probabile che in futuro vengano scoperti nuovi bypass.** Controlla i nostri [avvisi di sicurezza](https://github.com/patriksimek/vm2/security/advisories) per le vulnerabilità note.
2. **Devi mantenere vm2 aggiornato** per beneficiare delle ultime correzioni di sicurezza. Iscriviti agli avvisi di sicurezza e aggiorna tempestivamente.
3. **vm2 non dovrebbe essere la tua unica linea di difesa.** La difesa in profondità è essenziale quando si esegue codice non attendibile.
### Alternative Più Robuste
Se hai bisogno di garanzie di isolamento più forti, considera queste alternative che forniscono **un vero isolamento a livello di processo o hardware**:
| Soluzione | Approccio | Prestazioni | Compromessi |
|----------|----------|-------------|------------|
| **[isolated-vm](https://github.com/laverdet/isolated-vm)** | Isolati V8 separati (heap V8 diverso) | Veloce | In modalità manutenzione; richiede aggiornamenti manuali di V8 |
| **Processo separato / Worker** | `child_process` o thread Worker con permessi limitati | Medio | Maggiore overhead IPC; i dati devono essere serializzati |
| **Contenitori / VM** | Docker, gVisor, Firecracker | Lento | Overhead di avvio; uso intensivo di risorse |
| **Servizi gestiti** | Esecuzione di codice basata su cloud (es. AWS Lambda, Cloudflare Workers) | Variabile | Latenza di rete; dipendenza esterna |
### Quando vm2 Può Ancora Essere Appropriato
vm2 può essere adatto quando:
- Hai bisogno di una stretta integrazione con gli oggetti host e una comunicazione sincrona veloce
- Il codice non attendibile proviene da una fonte relativamente affidabile (es. strumenti interni, sistemi di plugin con autori verificati)
- Combini vm2 con altri livelli di sicurezza (isolamento di rete, restrizioni sul filesystem, limiti di risorse)
- Accetti il rischio e monitori attivamente gli aggiornamenti di sicurezza
**Se stai eseguendo codice da fonti completamente non attendibili (es. invii arbitrari da parte degli utenti), ti consigliamo vivamente di utilizzare una soluzione con garanzie di isolamento più forti.**
## Runtime
| Runtime | Stato |
|---------|--------|
| Node.js | Supportato. La sandbox è un confine di sicurezza. |
| Bun | **Sperimentale.** Compatibilità funzionale parziale — **non** è un confine di sicurezza. |
Due limitazioni separate si applicano a Bun, e nessuna implica l'altra.
**Non è un confine di sicurezza.** Il modello di minaccia di vm2, il catalogo degli attacchi in
[`docs/ATTACKS.md`](https://github.com/patriksimek/vm2/blob/main/docs/ATTACKS.md) e ogni test di regressione in `test/ghsa/`
derivano dagli interni di V8. JavaScriptCore, che Bun utilizza, ha i suoi
equivalenti, e nessuno è stato sottoposto ad audit rispetto al bridge di vm2. La suite che passa
sotto Bun dimostra compatibilità, non che la sandbox regga lì. **Non
usare vm2 su Bun per isolare codice non attendibile.**
**La compatibilità è parziale, non parità.** Un'esecuzione Bun verde copre solo i test
che vengono effettivamente eseguiti lì. `test/bun-skips.js` elenca cosa è escluso e perché,
e le lacune comportamentali note includono:
- `Buffer.from(arrayLike)` restituisce un buffer a lunghezza zero
- I metadati `filename` / `lineOffset` / `columnOffset` di `VMScript` non sono
osservabili, perché gli oggetti CallSite di JSC non hanno metodi
- `Object.freeze` su un oggetto host congelato con un accessor non configurabile
genera un `TypeError` di invariante proxy dove V8 non lo fa
- alcune operazioni `Buffer` attraverso il confine della sandbox sono drasticamente più lente —
un `allocUnsafe` da 64 MB richiede oltre 400 secondi contro 1.7 su Node, abbastanza lento
da sembrare un blocco
Tratta il supporto Bun come compatibilità best-effort per codice affidabile e controlla la
lista di esclusione prima di fare affidamento su un comportamento particolare.
## Caratteristiche
- Esegue codice non attendibile in modo sicuro in un singolo processo con il tuo codice affiancato
- Controllo completo sull'output della console della sandbox
- La sandbox ha accesso limitato ai metodi del processo
- È possibile richiedere moduli (integrati ed esterni) dalla sandbox
- Puoi limitare l'accesso a determinati (o tutti) i moduli integrati
- Puoi chiamare metodi in modo sicuro e scambiare dati e callback tra le sandbox
- Mantenuto attivamente con patch per i metodi di fuga noti (vedi [Dichiarazione di Sicurezza](#importante-dichiarazione-di-sicurezza))
- Supporto transpiler
## Come funziona
- Utilizza il modulo VM interno per creare un contesto sicuro.
- Utilizza [Proxy](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Proxy) per impedire la fuga dalla sandbox.
- Sostituisce il require integrato per controllare l'accesso ai moduli.
Per un'analisi approfondita degli interni di vm2, vedi [docs/ATTACKS.md](https://github.com/patriksimek/vm2/blob/main/docs/ATTACKS.md).
## Qual è la differenza tra il modulo vm di Node e vm2?
Provalo tu stesso:```js
import { runInNewContext } from "node:vm";
runInNewContext('this.constructor.constructor("return process")().exit()');
console.log('Never gets executed.');
Questa sezione elenca strumenti di sicurezza offensiva, inclusi framework di penetration testing, suite di exploit, strumenti di social engineering e toolkit di attacco. Questi strumenti sono progettati per test di sicurezza autorizzati e valutazioni di vulnerabilità.