patriksimek/vm2Sandbox JavaScript isolado para Node.js que executa código não confiável com acesso restrito a módulos integrados e recursos do host por meio de interceptação baseada em Proxy.
[![Known Vulnerabilities][snyk-image]][snyk-url]vm2 é um sandbox que pode executar código não confiável com módulos internos do Node.js na lista de permissões.
npm install vm2
## Exemplos Rápidos```js
import { VM } from 'vm2';
const vm = new VM();
vm.run(`process.exit()`); // TypeError: process.exit is not a function
I need the actual content of chunk 5 to translate it. Please provide the Markdown text you want translated.```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',
);
## Aviso de Segurança Importante
**Antes de usar o vm2, você deve entender como ele funciona e suas limitações.**
O vm2 tenta isolar código JavaScript não confiável **dentro do mesmo processo Node.js** da sua aplicação. Ele faz isso através de uma rede complexa de [Proxies](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Proxy) que interceptam e mediam cada interação entre o sandbox e o ambiente host.
### O Desafio Fundamental
JavaScript é uma linguagem extraordinariamente dinâmica. Objetos podem ser acessados através de cadeias de protótipos, construtores podem ser alcançados via objetos de erro, símbolos fornecem ganchos de protocolo, e a execução assíncrona cria janelas de temporização. A enorme quantidade de maneiras de percorrer de um objeto para outro em JavaScript torna extremamente difícil construir um sandbox in-process hermético.
**Somos honestos sobre essa realidade:** Apesar dos nossos melhores esforços, pesquisadores e profissionais de segurança continuamente descobrem novas maneiras de escapar do sandbox do vm2. Corrigimos ativamente essas vulnerabilidades conforme são reportadas, mas a natureza de gato e rato do sandboxing in-process significa que:
1. **Novas formas de bypass provavelmente serão descobertas no futuro.** Consulte nossos [avisos de segurança](https://github.com/patriksimek/vm2/security/advisories) para vulnerabilidades conhecidas.
2. **Você deve manter o vm2 atualizado** para se beneficiar das correções de segurança mais recentes. Assine os avisos de segurança e atualize prontamente.
3. **O vm2 não deve ser sua única linha de defesa.** Defesa em profundidade é essencial ao executar código não confiável.
### Alternativas Mais Robustas
Se você precisar de garantias de isolamento mais fortes, considere estas alternativas que fornecem **isolamento real em nível de processo ou hardware**:
| Solução | Abordagem | Desempenho | Trade-offs |
|----------|----------|-------------|------------|
| **[isolated-vm](https://github.com/laverdet/isolated-vm)** | Isolates V8 separados (heap V8 diferente) | Rápido | Em modo de manutenção; requer atualizações manuais do V8 |
| **Processo separado / Worker** | `child_process` ou threads Worker com permissões limitadas | Médio | Maior overhead de IPC; os dados devem ser serializados |
| **Containers / VMs** | Docker, gVisor, Firecracker | Lento | Overhead de inicialização; uso intensivo de recursos |
| **Serviços gerenciados** | Execução de código baseada em nuvem (ex.: AWS Lambda, Cloudflare Workers) | Variável | Latência de rede; dependência externa |
### Quando o vm2 Ainda Pode Ser Apropriado
O vm2 pode ser adequado quando:
- Você precisa de integração estreita com objetos host e comunicação síncrona rápida
- O código não confiável vem de uma fonte relativamente confiável (ex.: ferramentas internas, sistemas de plugins com autores avaliados)
- Você combina o vm2 com outras camadas de segurança (isolamento de rede, restrições de sistema de arquivos, limites de recursos)
- Você aceita o risco e monitora ativamente as atualizações de segurança
**Se você está executando código de fontes completamente não confiáveis (ex.: envios arbitrários de usuários), recomendamos fortemente usar uma solução com garantias de isolamento mais fortes.**
## Runtimes
| Runtime | Status |
|---------|--------|
| Node.js | Suportado. O sandbox é um limite de segurança. |
| Bun | **Experimental.** Compatibilidade funcional parcial — **não** é um limite de segurança. |
Duas limitações separadas se aplicam ao Bun, e nenhuma implica a outra.
**Não é um limite de segurança.** O modelo de ameaças do vm2, o catálogo de ataques em
[`docs/ATTACKS.md`](https://github.com/patriksimek/vm2/blob/main/docs/ATTACKS.md), e todos os testes de regressão em `test/ghsa/`
são derivados de internals do V8. O JavaScriptCore, que o Bun usa, tem seus próprios
equivalentes, e nenhum foi auditado contra a ponte do vm2. A suíte passando
sob o Bun demonstra compatibilidade, não que o sandbox se sustente lá. **Não
use o vm2 no Bun para isolar código não confiável.**
**A compatibilidade é parcial, não paridade.** Uma execução verde no Bun cobre apenas os testes
que realmente executam lá. `test/bun-skips.js` lista o que é excluído e por quê,
e as lacunas comportamentais conhecidas incluem:
- `Buffer.from(arrayLike)` retorna um buffer de comprimento zero
- Os metadados `filename` / `lineOffset` / `columnOffset` do `VMScript` não são
observáveis, porque os objetos CallSite do JSC não carregam métodos
- `Object.freeze` em um objeto host congelado com um accessor não configurável
lança um `TypeError` de invariante de proxy onde o V8 não lança
- algumas operações de `Buffer` através do limite do sandbox são drasticamente mais lentas —
um `allocUnsafe` de 64 MB leva mais de 400 segundos contra 1,7 no Node, lento o suficiente
para parecer um travamento
Trate o suporte ao Bun como compatibilidade de melhor esforço para código confiável, e verifique a
lista de exclusões antes de confiar em qualquer comportamento específico.
## Recursos
- Executa código não confiável com segurança em um único processo, lado a lado com seu código
- Controle total sobre a saída do console do sandbox
- O sandbox tem acesso limitado aos métodos do processo
- É possível exigir módulos (embutidos e externos) a partir do sandbox
- Você pode limitar o acesso a certos (ou todos) módulos embutidos
- Você pode chamar métodos com segurança e trocar dados e callbacks entre sandboxes
- Mantido ativamente com correções para métodos de escape conhecidos (veja [Aviso de Segurança](#aviso-de-segurança-importante))
- Suporte a transpilador
## Como funciona
- Usa o módulo VM interno para criar um contexto seguro.
- Usa [Proxies](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/Proxy) para impedir a fuga do sandbox.
- Substitui o require embutido para controlar o acesso aos módulos.
Para uma análise aprofundada dos internals do vm2, veja [docs/ATTACKS.md](https://github.com/patriksimek/vm2/blob/main/docs/ATTACKS.md).
## Qual é a diferença entre o vm do Node e o vm2?
Experimente você mesmo:```js
import { runInNewContext } from "node:vm";
runInNewContext('this.constructor.constructor("return process")().exit()');
console.log('Never gets executed.');
O Metasploit Framework é uma infraestrutura de código aberto que você pode usar para testes de segurança, desenvolvimento de assinaturas e pesquisa. A estrutura é uma coleção de ferramentas comumente usadas que fornece um ambiente completo para testes de penetração e desenvolvimento de exploits.