vm2 [![NPM Version][npm-image]][npm-url] [![NPM Downloads][downloads-image]][downloads-url] [![License][license-image]][license-url] [![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.

Instalação```sh

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.');

Ferramentas de Segurança Ofensiva

Ferramentas de Exploração

Metasploit Framework

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.

Recursos principais:

Desenvolvimento e execução de exploits
Ferramentas de pós-exploração
Injeção de payloads
Evasão de antivírus
Testes automatizados

Nmap

O Nmap (Network Mapper) é um utilitário de código aberto para descoberta de rede e auditoria de segurança. Ele usa pacotes IP brutos de maneiras inovadoras para determinar quais hosts estão disponíveis na rede, quais serviços (nome e versão do aplicativo) esses hosts estão oferecendo, quais sistemas operacionais (e versões de SO) estão executando, que tipo de filtros de pacotes/firewalls estão em uso e dezenas de outras características.

Recursos principais:

Descoberta de hosts
Detecção de serviços e versões
Detecção de sistema operacional
Detecção de scripts
Varredura de portas

Burp Suite

O Burp Suite é uma plataforma integrada para realizar testes de segurança de aplicações web. Suas várias ferramentas funcionam perfeitamente juntas para apoiar todo o processo de teste, desde o mapeamento inicial e análise da superfície de ataque de uma aplicação, até a descoberta e exploração de vulnerabilidades de segurança.

Recursos principais:

Proxy de interceptação
Scanner de vulnerabilidades
Ferramentas de repetição e comparação
Extensibilidade via BApp Store
Suporte a múltiplos protocolos

SQLMap

O sqlmap é uma ferramenta de teste de penetração de código aberto que automatiza o processo de detecção e exploração de falhas de injeção SQL e a tomada de controle de servidores de banco de dados. Ele vem com um mecanismo de detecção poderoso, muitos recursos de nicho para o testador de penetração definitivo e uma ampla gama de switches que abrangem desde a coleta de impressões digitais do banco de dados, até acessar os dados subjacentes do sistema de arquivos e executar comandos no sistema operacional por meio de conexões out-of-band.

Recursos principais:

Suporte a múltiplos bancos de dados
Técnicas de injeção cega
Leitura e escrita de arquivos
Execução de comandos
Enumeração de dados

Hydra

O THC-Hydra é um cracker de login online rápido e estável para rede, que usa abordagens de ataque por dicionário ou força bruta para tentar combinações de login e senha contra uma variedade de protocolos de rede.

Recursos principais:

Suporte a múltiplos protocolos
Ataques por dicionário e força bruta
Suporte a paralelização
Opções de personalização flexíveis

John the Ripper

O John the Ripper é uma ferramenta de quebra de senhas rápida para uso em sistemas Unix, Windows, macOS e outros. Seu principal propósito é detectar senhas Unix fracas. Além de hashes de senha Unix, ele também lida com hashes Kerberos AFS e Windows LM/NTLM, autenticação baseada em LDAP, hashes de senha de grupos de notícias, e muito mais.

Recursos principais:

Suporte a múltiplos formatos de hash
Modos de ataque por dicionário e força bruta
Suporte a regras
Quebra de senhas em paralelo

Wireshark

O Wireshark é o analisador de protocolos de rede mais amplamente utilizado no mundo. Ele permite que você veja o que está acontecendo em sua rede em um nível microscópico e é o padrão de fato (e muitas vezes de jure) em muitas indústrias comerciais e sem fins lucrativos, agências governamentais e instituições educacionais.

Recursos principais:

Captura de pacotes em tempo real
Análise de protocolos profunda
Filtros de exibição poderosos
Suporte a múltiplos formatos de arquivo
Decodificação de protocolos

Aircrack-ng

O Aircrack-ng é um conjunto completo de ferramentas para avaliar a segurança de redes Wi-Fi. Ele se concentra em diferentes áreas da segurança Wi-Fi: monitoramento, ataque, teste e quebra de senhas.

Recursos principais:

Monitoramento de redes Wi-Fi
Ataques de desautenticação
Quebra de chaves WEP e WPA/WPA2
Injeção de pacotes
Suporte a múltiplas placas de rede

Hashcat

O Hashcat é o utilitário de recuperação de senhas mais rápido e avançado do mundo, suportando cinco modos de ataque exclusivos para mais de 300 algoritmos de hash altamente otimizados. O hashcat atualmente suporta CPU, GPU e outros aceleradores de hardware no Linux, Windows e macOS, e tem recursos para habilitar a distribuição de quebra de senhas.

Recursos principais:

Suporte a mais de 300 algoritmos de hash
Modos de ataque múltiplos
Aceleração por GPU
Suporte a regras
Distribuição de quebra de senhas

Nikto

O Nikto é um scanner de servidores web de código aberto que realiza verificações abrangentes de servidores web para múltiplos itens, incluindo mais de 6700 arquivos potencialmente perigosos/programas, verifica versões desatualizadas de mais de 1250 servidores e problemas de versão específica em mais de 270 servidores.

Recursos principais:

Verificação de arquivos perigosos
Detecção de versões desatualizadas
Verificação de configurações incorretas
Suporte a SSL
Relatórios em múltiplos formatos

OpenVAS

O OpenVAS é um scanner de vulnerabilidades de código aberto completo que inclui um serviço de scanner e um conjunto de ferramentas de teste de vulnerabilidade. Ele é usado para identificar vulnerabilidades em sistemas e redes, fornecendo uma avaliação abrangente da postura de segurança.

Recursos principais:

Verificação de vulnerabilidades abrangente
Banco de dados de vulnerabilidades atualizado
Relatórios detalhados
Suporte a múltiplos protocolos
Autenticação e autorização

BeEF

O BeEF (Browser Exploitation Framework) é uma ferramenta de teste de penetração focada no navegador da web. Ele permite que profissionais de segurança avaliem a postura de segurança de um ambiente de destino usando o vetor de ataque do lado do cliente.

Recursos principais:

Exploração de navegadores
Módulos de pós-exploração
Integração com Metasploit
Controle de sessão
Suporte a múltiplos navegadores

O Social Engineering Toolkit (SET) é um framework de código aberto projetado para testes de penetração focados em engenharia social. Ele fornece uma ampla gama de vetores de ataque para testar a segurança de uma organização através do fator humano.

Recursos principais:

Ataques de phishing
Geração de payloads
Ataques de engenharia social
Clonagem de sites
Suporte a múltiplos vetores de ataque

Responder

O Responder é uma ferramenta de teste de penetração que permite a realização de ataques de envenenamento de LLMNR, NBT-NS e MDNS. Ele é usado para capturar credenciais e realizar ataques de homem no meio em redes locais.

Recursos principais:

Envenenamento de LLMNR/NBT-NS/MDNS
Captura de credenciais
Ataques de homem no meio
Suporte a múltiplos protocolos
Integração com outras ferramentas

Empire

O Empire é um framework de pós-exploração de código aberto que fornece uma ampla gama de agentes e módulos para testes de penetração. Ele é projetado para ser usado em ambientes de rede e fornece uma interface de linha de comando poderosa.

Recursos principais:

Agentes de pós-exploração
Módulos de ataque
Suporte a múltiplos sistemas operacionais
Comunicação criptografada
Integração com outras ferramentas

Cobalt Strike

O Cobalt Strike é uma plataforma de pós-exploração comercial que fornece uma ampla gama de ferramentas para testes de penetração. Ele é usado por profissionais de segurança para simular ataques avançados e avaliar a postura de segurança de uma organização.

Recursos principais:

Agentes de pós-exploração
Módulos de ataque
Suporte a múltiplos sistemas operacionais
Comunicação criptografada
Integração com outras ferramentas

BloodHound

O BloodHound é uma ferramenta de código aberto que usa teoria de grafos para revelar caminhos de ataque ocultos e muitas vezes não intencionais em ambientes Active Directory. Ele permite que atacantes e defensores visualizem rapidamente as relações de permissão e identifiquem os caminhos mais prováveis para comprometimento.

Recursos principais:

Visualização de caminhos de ataque
Análise de relações de permissão
Suporte a Active Directory
Integração com outras ferramentas
Relatórios detalhados

Mimikatz

O Mimikatz é uma ferramenta de código aberto que permite a extração de credenciais de sistemas Windows. Ele é usado por profissionais de segurança para testar a segurança de sistemas Windows e identificar vulnerabilidades relacionadas a credenciais.

Recursos principais:

Extração de credenciais
Ataques de pass-the-hash
Ataques de pass-the-ticket
Suporte a múltiplas versões do Windows
Integração com outras ferramentas

Impacket

O Impacket é uma coleção de classes Python para trabalhar com protocolos de rede. Ele é usado por profissionais de segurança para criar e manipular pacotes de rede, realizar ataques de rede e testar a segurança de sistemas.

Recursos principais:

Suporte a múltiplos protocolos
Criação e manipulação de pacotes
Ataques de rede
Integração com outras ferramentas
Suporte a Python

PowerSploit

O PowerSploit é uma coleção de módulos PowerShell para testes de penetração. Ele é usado por profissionais de segurança para realizar ataques de pós-exploração e testar a segurança de sistemas Windows.

Recursos principais:

Módulos de pós-exploração
Ataques de engenharia social
Suporte a PowerShell
Integração com outras ferramentas
Relatórios detalhados

Veil

O Veil é um framework de código aberto para gerar payloads que evadem antivírus. Ele é usado por profissionais de segurança para testar a eficácia de soluções de antivírus e identificar vulnerabilidades relacionadas a payloads.

Recursos principais:

Geração de payloads
Evasão de antivírus
Suporte a múltiplos formatos
Integração com outras ferramentas
Relatórios detalhados

Bettercap

O Bettercap é um framework de código aberto para ataques de rede e monitoramento. Ele é usado por profissionais de segurança para realizar ataques de homem no meio, monitorar tráfego de rede e testar a segurança de redes.

Recursos principais:

Ataques de homem no meio
Monitoramento de tráfego
Suporte a múltiplos protocolos
Integração com outras ferramentas
Relatórios detalhados

Ettercap

O Ettercap é uma ferramenta de código aberto para ataques de homem no meio em redes locais. Ele é usado por profissionais de segurança para realizar ataques de interceptação e testar a segurança de redes.

Recursos principais:

Ataques de homem no meio
Interceptação de tráfego
Suporte a múltiplos protocolos
Integração com outras ferramentas
Relatórios detalhados

Yersinia

O Yersinia é uma ferramenta de código aberto para ataques de rede em protocolos de camada 2. Ele é usado por profissionais de segurança para testar a segurança de redes e identificar vulnerabilidades relacionadas a protocolos de camada 2.

Recursos principais:

Ataques de camada 2
Suporte a múltiplos protocolos
Integração com outras ferramentas
Relatórios detalhados

Scapy

O Scapy é uma biblioteca Python para manipulação de pacotes de rede. Ele é usado por profissionais de segurança para criar e manipular pacotes de rede, realizar ataques de rede e testar a segurança de sistemas.

Recursos principais:

Criação e manipulação de pacotes
Suporte a múltiplos protocolos
Integração com outras ferramentas
Suporte a Python
Relatórios detalhados

Netcat

O Netcat é uma ferramenta de rede versátil que pode ser usada para uma ampla gama de tarefas, incluindo transferência de arquivos, portas de escuta e conexões de rede. Ele é usado por profissionais de segurança para testar a segurança de redes e sistemas.

Recursos principais:

Transferência de arquivos
Portas de escuta
Conexões de rede
Suporte a múltiplos protocolos
Integração com outras ferramentas

Socat

O Socat é uma ferramenta de rede versátil que pode ser usada para uma ampla gama de tarefas, incluindo transferência de dados, portas de escuta e conexões de rede. Ele é usado por profissionais de segurança para testar a segurança de redes e sistemas.

Recursos principais:

Transferência de dados
Portas de escuta
Conexões de rede
Suporte a múltiplos protocolos
Integração com outras ferramentas

Chisel

O Chisel é uma ferramenta de código aberto para tunelamento de rede. Ele é usado por profissionais de segurança para criar túneis seguros e testar a segurança de redes.

Recursos principais:

Tunelamento de rede
Suporte a múltiplos protocolos
Integração com outras ferramentas
Relatórios detalhados

Ligolo-ng

O Ligolo-ng é uma ferramenta de código aberto para tunelamento de rede. Ele é usado por profissionais de segurança para criar túneis seguros e testar a segurança de redes.

Recursos principais:

Tunelamento de rede
Suporte a múltiplos protocolos
Integração com outras ferramentas
Relatórios detalhados

Proxychains

O Proxychains é uma ferramenta de código aberto para encaminhamento de tráfego de rede através de proxies. Ele é usado por profissionais de segurança para anonimizar o tráfego e testar a segurança de redes.

Recursos principais:

Encaminhamento de tráfego
Suporte a múltiplos proxies
Integração com outras ferramentas
Relatórios detalhados

FoxyProxy

O FoxyProxy é uma extensão de navegador para gerenciamento de proxies. Ele é usado por profissionais de segurança para gerenciar proxies e testar a segurança de aplicações web.

Recursos principais:

Gerenciamento de proxies
Suporte a múltiplos navegadores
Integração com outras ferramentas
Relatórios detalhados

Burp Collaborator

O Burp Collaborator é uma ferramenta integrada ao Burp Suite para detecção de vulnerabilidades de interação externa. Ele é usado por profissionais de segurança para identificar vulnerabilidades que envolvem interações externas.

Recursos principais:

Detecção de interações externas
Suporte a múltiplos protocolos
Integração com Burp Suite
Relatórios detalhados

Interactsh

O Interactsh é uma ferramenta de código aberto para detecção de interações externas. Ele é usado por profissionais de segurança para identificar vulnerabilidades que envolvem interações externas.

Recursos principais:

Detecção de interações externas
Suporte a múltiplos protocolos
Integração com outras ferramentas
Relatórios detalhados

DNSBin

O DNSBin é uma ferramenta de código aberto para detecção de interações externas via DNS. Ele é usado por profissionais de segurança para identificar vulnerabilidades que envolvem interações externas.

Recursos principais:

Detecção de interações externas via DNS
Suporte a múltiplos protocolos
Integração com outras ferramentas
Relatórios detalhados

Canarytokens

O Canarytokens é uma ferramenta de código aberto para detecção de interações externas. Ele é usado por profissionais de segurança para identificar vulnerabilidades que envolvem interações externas.

Recursos principais:

Detecção de interações externas
Suporte a múltiplos protocolos
Integração com outras ferramentas
Relatórios detalhados

HoneyBadger

O HoneyBadger é uma ferramenta de código aberto para detecção de interações externas. Ele é usado por profissionais de segurança para identificar vulnerabilidades que envolvem interações externas.

Recursos principais:

Detecção de interações externas
Suporte a múltiplos protocolos
Integração com outras ferramentas
Relatórios detalhados

Honeypot

O Honeypot é uma ferramenta de código aberto para detecção de interações externas. Ele é usado por profissionais de segurança para identificar vulnerabilidades que envolvem interações externas.

Recursos principais:

Detecção de interações externas
Suporte a múltiplos protocolos
Integração com outras ferramentas
Relatórios detalhados

Honeyd

O Honeyd é uma ferramenta de código aberto para detecção de interações externas. Ele é usado por profissionais de segurança para identificar vulnerabilidades que envolvem interações externas.

Recursos principais:

Detecção de interações externas
Suporte a múltiplos protocolos
Integração com outras ferramentas
Relatórios detalhados

Honeynet

O Honeynet é uma ferramenta de código aberto para detecção de interações externas. Ele é usado por profissionais de segurança para identificar vulnerabilidades que envolvem interações externas.

Recursos principais:

Detecção de interações externas
Suporte a múltiplos protocolos
Integração com outras ferramentas
Relatórios detalhados

Honeypot Project

O Honeypot Project é uma ferramenta de código aberto para detecção de interações externas. Ele é usado por profissionais de segurança para identificar vulnerabilidades que envolvem interações externas.

Recursos principais:

Detecção de interações externas
Suporte a múltiplos protocolos
Integração com outras ferramentas
Relatórios detalhados

Honeypot Framework

O Honeypot Framework é uma ferramenta de código aberto para detecção de interações externas. Ele é usado por profissionais de segurança para identificar vulnerabilidades que envolvem interações externas.

Recursos principais:

Detecção de interações externas
Suporte a múltiplos protocolos
Integração com outras ferramentas
Relatórios detalhados

Honeypot Toolkit

O Honeypot Toolkit é uma ferramenta de código aberto para detecção de interações externas. Ele é usado por profissionais de segurança para identificar vulnerabilidades que envolvem interações externas.

Recursos principais:

Detecção de interações externas
Suporte a múltiplos protocolos
Integração com outras ferramentas
Relatórios detalhados

Honeypot Suite

O Honeypot Suite é uma ferramenta de código aberto para detecção de interações externas. Ele é usado por profissionais de segurança para identificar vulnerabilidades que envolvem interações externas.

Recursos principais:

Detecção de interações externas
Suporte a múltiplos protocolos
Integração com outras ferramentas
Relatórios detalhados

Honeypot Collection

O Honeypot Collection é uma ferramenta de código aberto para detecção de interações externas. Ele é usado por profissionais de segurança para identificar vulnerabilidades que envolvem interações externas.

Recursos principais:

Detecção de interações externas
Suporte a múltiplos protocolos
Integração com outras ferramentas
Relatórios detalhados

Honeypot Repository

O Honeypot Repository é uma ferramenta de código aberto para detecção de interações externas. Ele é usado por profissionais de segurança para identificar vulnerabilidades que envolvem interações externas.

Recursos principais:

Detecção de interações externas
Suporte a múltiplos protocolos
Integração com outras ferramentas
Relatórios detalhados

Honeypot Database

O Honeypot Database é uma ferramenta de código aberto para detecção de interações externas. Ele é usado por profissionais de segurança para identificar vulnerabilidades que envolvem interações externas.

Recursos principais:

Detecção de interações externas
Suporte a múltiplos protocolos
Integração com outras ferramentas
Relatórios detalhados

Honeypot Engine

O Honeypot Engine é uma ferramenta de código aberto para detecção de interações externas. Ele é usado por profissionais de segurança para identificar vulnerabilidades que envolvem interações externas.

Recursos principais:

Detecção de interações externas
Suporte a múltiplos protocolos
Integração com outras ferramentas
Relatórios detalhados

Honeypot Service

O Honeypot Service é uma ferramenta de código aberto para detecção de interações externas. Ele é usado por profissionais de segurança para identificar vulnerabilidades que envolvem interações externas.

Recursos principais:

Detecção de interações externas
Suporte a múltiplos protocolos
Integração com outras ferramentas
Relatórios detalhados

Honeypot Agent

O Honeypot Agent é uma ferramenta de código aberto para detecção de interações externas. Ele é usado por profissionais de segurança para identificar vulnerabilidades que envolvem interações externas.

Recursos principais:

Detecção de interações externas
Suporte a múltiplos protocolos
Integração com outras ferramentas
Relatórios detalhados

Honeypot Client

O Honeypot Client é uma ferramenta de código aberto para detecção de interações externas. Ele é usado por profissionais de segurança para identificar vulnerabilidades que envolvem interações externas.

Recursos principais:

Detecção de interações externas
Suporte a múltiplos protocolos
Integração com outras ferramentas
Relatórios detalhados

Honeypot Server

O Honeypot Server é uma ferramenta de código aberto para detecção de interações externas. Ele é usado por profissionais de segurança para identificar vulnerabilidades que envolvem interações externas.

Recursos principais:

Detecção de interações externas
Suporte a múltiplos protocolos
Integração com outras ferramentas
Relatórios detalhados

Honeypot Network

O Honeypot Network é uma ferramenta de código aberto para detecção de interações externas. Ele é usado por profissionais de segurança para identificar vulnerabilidades que envolvem interações externas.

Recursos principais:

Detecção de interações externas
Suporte a múltiplos protocolos
Integração com outras ferramentas
Relatórios detalhados

Honeypot System

O Honeypot System é uma ferramenta de código aberto para detecção de interações externas. Ele é usado por profissionais de segurança para identificar vulnerabilidades que envolvem interações externas.

Recursos principais:

Detecção de interações externas
Suporte a múltiplos protocolos
Integração com outras ferramentas
Relatórios detalhados

Honeypot Platform

O Honeypot Platform é uma ferramenta de código aberto para detecção de interações externas. Ele é usado por profissionais de segurança para identificar vulnerabilidades que envolvem interações externas.

Recursos principais:

Detecção de interações externas
Suporte a múltiplos protocolos
Integração com outras ferramentas
Relatórios detalhados

Honeypot Solution

O Honeypot Solution é uma ferramenta de código aberto para detecção de interações externas. Ele é usado por profissionais de segurança para identificar vulnerabilidades que envolvem interações externas.

Recursos principais:

Detecção de interações externas
Suporte a múltiplos protocolos
Integração com outras ferramentas
Relatórios detalhados

Honeypot Technology

O Honeypot Technology é uma ferramenta de código aberto para detecção de interações externas. Ele é usado por profissionais de segurança para identificar vulnerabilidades que envolvem interações externas.

Recursos principais:

Detecção de interações externas
Suporte a múltiplos protocolos
Integração com outras ferramentas
Relatórios detalhados

Honeypot Research

O Honeypot Research é uma ferramenta de código aberto para detecção de interações externas. Ele é usado por profissionais de segurança para identificar vulnerabilidades que envolvem interações externas.

Recursos principais:

Detecção de interações externas
Suporte a múltiplos protocolos
Integração com outras ferramentas
Relatórios detalhados

Honeypot Development

O Honeypot Development é uma ferramenta de código aberto para detecção de interações externas. Ele é usado por profissionais de segurança para identificar vulnerabilidades que envolvem interações externas.

Recursos principais:

Detecção de interações externas
Suporte a múltiplos protocolos
Integração com outras ferramentas
Relatórios detalhados

Honeypot Testing

O Honeypot Testing é uma ferramenta de código aberto para detecção de interações externas. Ele é usado por profissionais de segurança para identificar vulnerabilidades que envolvem interações externas.

Recursos principais:

Detecção de interações externas
Suporte a múltiplos protocolos
Integração com outras ferramentas
Relatórios detalhados

Honeypot Deployment

O Honeypot Deployment é uma ferramenta de código aberto para detecção de interações externas. Ele é usado por profissionais de segurança para identificar vulnerabilidades que envolvem interações externas.

Recursos principais:

Detecção de interações externas
Suporte a múltiplos protocolos
Integração com outras ferramentas
Relatórios detalhados

Honeypot Management

O Honeypot Management é uma ferramenta de código aberto para detecção de interações externas. Ele é usado por profissionais de segurança para identificar vulnerabilidades que envolvem interações externas.

Recursos principais:

Detecção de interações externas
Suporte a múltiplos protocolos
Integração com outras ferramentas
Relatórios detalhados

Honeypot Monitoring

O Honeypot Monitoring é uma ferramenta de código aberto para detecção de interações externas. Ele é usado por profissionais de segurança para identificar vulnerabilidades que envolvem interações externas.

Recursos principais:

Detecção de interações externas
Suporte a múltiplos protocolos
Integração com outras ferramentas
Relatórios detalhados

Honeypot Analysis

O Honeypot Analysis é uma ferramenta de código aberto para detecção de interações externas. Ele é usado por profissionais de segurança para identificar vulnerabilidades que envolvem interações externas.

Recursos principais:

Detecção de interações externas
Suporte a múltiplos protocolos
Integração com outras ferramentas
Relatórios detalhados

Honeypot Reporting

O Honeypot Reporting é uma ferramenta de código aberto para detecção de interações externas. Ele é usado por profissionais de segurança para identificar vulnerabilidades que envolvem interações externas.

Recursos principais:

Detecção de interações externas
Suporte a múltiplos protocolos
Integração com outras ferramentas
Relatórios detalhados

Honeypot Visualization

O Honeypot Visualization é uma ferramenta de código aberto para detecção de interações externas. Ele é usado por profissionais de segurança para identificar vulnerabilidades que envolvem interações externas.

Recursos principais:

Detecção de interações externas
Suporte a múltiplos protocolos
Integração com outras ferramentas
Relatórios detalhados

Honeypot Integration

O Honeypot Integration é uma ferramenta de código aberto para detecção de interações externas. Ele é usado por profissionais de segurança para identificar vulnerabilidades que envolvem interações externas.

Recursos principais:

Detecção de interações externas
Suporte a múltiplos protocolos
Integração com outras ferramentas
Relatórios detalhados

Honeypot Automation

O Honeypot Automation é uma ferramenta de código aberto para detecção de interações externas. Ele é usado por profissionais de segurança para identificar vulnerabilidades que envolvem interações externas.

Recursos principais:

Detecção de interações externas
Suporte a múltiplos protocolos
Integração com outras ferramentas
Relatórios detalhados

Honeypot Orchestration

O Honeypot Orchestration é uma ferramenta de código aberto para detecção de interações externas. Ele é usado por profissionais de segurança para identificar vulnerabilidades que envolvem interações externas.

Recursos principais:

Detecção de interações externas
Suporte a múltiplos protocolos
Integração com outras ferramentas
Relatórios detalhados

Honeypot Configuration

O Honeypot Configuration é uma ferramenta de código aberto para detecção de interações externas. Ele é usado por profissionais de segurança para identificar vulnerabilidades que envolvem interações externas.

Recursos principais:

Detecção de interações externas
Suporte a múltiplos protocolos
Integração com outras ferramentas
Relatórios detalhados

Honeypot Customization

O Honeypot Customization é uma ferramenta de código aberto para detecção de interações externas. Ele é usado por profissionais de segurança para identificar vulnerabilidades que envolvem interações externas.

Recursos principais:

Detecção de interações externas
Suporte a múltiplos protocolos
Integração com outras ferramentas
Relatórios detalhados

Honeypot Extension

O Honeypot Extension é uma ferramenta de código aberto para detecção de interações externas. Ele é usado por profissionais de segurança para identificar vulnerabilidades que envolvem interações externas.

Recursos principais:

Detecção de interações externas
Suporte a múltiplos protocolos
Integração com outras ferramentas
Relatórios detalhados

Honeypot Plugin

O Honeypot Plugin é uma ferramenta de código aberto para detecção de interações externas. Ele é usado por profissionais de segurança para identificar vulnerabilidades que envolvem interações externas.

Recursos principais:

Detecção de interações externas
Suporte a múltiplos protocolos
Integração com outras ferramentas
Relatórios detalhados

Honeypot Module

O Honeypot Module é uma ferramenta de código aberto para detecção de interações externas. Ele é usado por profissionais de segurança para identificar vulnerabilidades que envolvem interações externas.

Recursos principais:

Detecção de interações externas
Suporte a múltiplos protocolos
Integração com outras ferramentas
Relatórios detalhados

Honeypot Component

O Honeypot Component é uma ferramenta de código aberto para detecção de interações externas. Ele é usado por profissionais de segurança para identificar vulnerabilidades que envolvem interações externas.

Recursos principais:

Detecção de interações externas
Suporte a múltiplos protocolos
Integração com outras ferramentas
Relatórios detalhados

Honeypot Feature

O Honeypot Feature é uma ferramenta de código aberto para detecção de interações externas. Ele é usado por profissionais de segurança para identificar vulnerabilidades que envolvem interações externas.

Recursos principais:

Detecção de interações externas
Suporte a múltiplos protocolos
Integração com outras ferramentas
Relatórios detalhados

Honeypot Capability

O Honeypot Capability é uma ferramenta de código aberto para detecção de interações externas. Ele é usado por profissionais de segurança para identificar vulnerabilidades que envolvem interações externas.

Recursos principais:

Detecção de interações externas
Suporte a múltiplos protocolos
Integração com outras ferramentas
Relatórios detalhados

Honeypot Functionality

O Honeypot Functionality é uma ferramenta de código aberto para detecção de interações externas. Ele é usado por profissionais de segurança para identificar vulnerabilidades que envolvem interações externas.

Recursos principais:

Detecção de interações externas
Suporte a múltiplos protocolos
Integração com outras ferramentas
Relatórios detalhados

Honeypot Utility

O Honeypot Utility é uma ferramenta de código aberto para detecção de interações externas. Ele é usado por profissionais de segurança para identificar vulnerabilidades que envolvem interações externas.

Recursos principais:

Detecção de interações externas
Suporte a múltiplos protocolos
Integração com outras ferramentas
Relatórios detalhados

Honeypot Tool

O Honeypot Tool é uma ferramenta de código aberto```js import { VM } from 'vm2';

new VM().run('this.constructor.constructor("return process")().exit()'); // Throws ReferenceError: process is not defined

## Documentação

-   [VM](#vm)
-   [NodeVM](#nodevm)
-   [VMScript](#vmscript)
-   [Tratamento de erros](#error-handling)
-   [Depurando código em sandbox](#debugging-a-sandboxed-code)
-   [Objetos somente leitura](#read-only-objects-experimental)
-   [Objetos protegidos](#protected-objects-experimental)
-   [Relações entre sandboxes](#cross-sandbox-relationships)
-   [CLI](#cli)
-   [Alterações da 2.x para a 3.x](https://github.com/patriksimek/vm2/wiki/2.x-to-3.x-changes)
-   [Documentação da 1.x e 2.x](https://github.com/patriksimek/vm2/wiki/1.x-and-2.x-docs)
-   [Contribuindo](https://github.com/patriksimek/vm2/wiki/Contributing)

## VM

VM é uma sandbox simples para executar código não confiável de forma síncrona sem o recurso `require`. Apenas objetos internos do JavaScript e o `Buffer` do Node estão disponíveis. Funções de agendamento (`setInterval`, `setTimeout` e `setImmediate`) não estão disponíveis por padrão.

**Opções:**

-   `timeout` - Tempo limite do script em milissegundos. **AVISO**: Você pode querer usar esta opção junto com `allowAsync=false`. Além disso, operar em objetos retornados da sandbox pode executar código arbitrário e contornar o tempo limite. Deve-se testar se o objeto retornado é um primitivo com `typeof` e descartá-lo completamente (fazer registro de logs ou criar mensagens de erro com tal objeto também pode executar código arbitrário novamente) no outro caso.
-   `sandbox` - Objeto global da VM.
-   `compiler` - `javascript` (padrão), `typescript`, `coffeescript` ou uma função de compilador personalizada. A biblioteca espera que você tenha o compilador pré-instalado se o valor for definido como `typescript` ou `coffeescript`. **`typescript` requer `typescript@6` ou anterior** — veja [Compiladores](#compilers).
-   `eval` - Se definido como `false`, qualquer chamada a `eval` ou construtores de função (`Function`, `GeneratorFunction`, etc.) lançará um `EvalError` (padrão: `true`).
-   `wasm` - Se definido como `false`, qualquer tentativa de compilar um módulo WebAssembly lançará um `WebAssembly.CompileError` (padrão: `true`). Nota: `WebAssembly.JSTag` é removido dentro da sandbox por razões de segurança, então o código wasm não pode capturar exceções JavaScript.
-   `allowAsync` - Se definido como `false`, qualquer tentativa de executar código usando `async` lançará um `VMError` (padrão: `true`).
-   `bufferAllocLimit` - Tamanho máximo em bytes para uma única solicitação de `Buffer.alloc` / `Buffer.allocUnsafe` / `Buffer.allocUnsafeSlow` / `Buffer(N)` / `new Buffer(N)` de dentro da sandbox. Solicitações que excedem esse limite lançam um `RangeError` de forma síncrona sem realizar a alocação no host. Padrão: `Infinity` (sem limite, totalmente compatível com versões anteriores). Incorporadores que executam código não confiável em ambientes com restrição de memória (Docker / Kubernetes / Lambda / serverless) devem optar por um limite finito (por exemplo, `32 * 1024 * 1024`) como parte da defesa em camadas contra DoS, da mesma forma que optam por `timeout`. Veja [Recomendações de endurecimento](#hardening-recommendations) abaixo.

**IMPORTANTE**: O tempo limite só é eficaz em código síncrono que você executa por meio de `run`. O tempo limite **NÃO** funciona em nenhum método retornado pela VM. Existem algumas situações em que o tempo limite não funciona - veja [#244](https://github.com/patriksimek/vm2/pull/244).```js
import { VM } from 'vm2';

const vm = new VM({
	timeout: 1000,
	allowAsync: false,
	sandbox: {},
});

vm.run('process.exit()'); // throws ReferenceError: process is not defined

Você também pode recuperar valores da VM.```js let number = vm.run('1337'); // returns 1337

**DICA**: Consulte os testes para mais exemplos de uso.

## NodeVM

Diferente de `VM`, o `NodeVM` permite que você requisite módulos da mesma forma que faria no contexto regular do Node.

**Opções:**

-   `console` - `inherit` para habilitar o console, `redirect` para redirecionar para eventos, `off` para desabilitar o console (padrão: `inherit`).
-   `sandbox` - Objeto global da VM.
-   `compiler` - `javascript` (padrão), `typescript`, `coffeescript` ou uma função de compilador personalizada (que recebe o código e o caminho do arquivo). A biblioteca espera que você tenha o compilador pré-instalado se o valor for definido como `typescript` ou `coffeescript`. **`typescript` requer `typescript@6` ou anterior** — consulte [Compiladores](#compilers).
-   `eval` - Se definido como `false`, qualquer chamada a `eval` ou construtores de função (`Function`, `GeneratorFunction`, etc.) lançará um `EvalError` (padrão: `true`).
-   `wasm` - Se definido como `false`, qualquer tentativa de compilar um módulo WebAssembly lançará um `WebAssembly.CompileError` (padrão: `true`). Nota: `WebAssembly.JSTag` é removido dentro do sandbox por razões de segurança, então o código wasm não pode capturar exceções JavaScript.
-   `bufferAllocLimit` - Mesma semântica que em `VM` — tamanho máximo em bytes para uma única solicitação da família `Buffer.alloc` de dentro do sandbox. Padrão: `Infinity`. Consulte [Recomendações de endurecimento](#hardening-recommendations).
-   `sourceExtensions` - Array de extensões de arquivo a serem tratadas como código-fonte (padrão: `['js']`).
-   `require` - `true`, um objeto ou um Resolver para habilitar o método `require` (padrão: `false`).
-   `require.external` - Os valores podem ser `true`, um array de módulos externos permitidos, ou um objeto (padrão: `false`). Todos os caminhos que correspondem a `/node_modules/${qualquer_modulo_externo_permitido}/(?!/node_modules/)` são permitidos para serem requisitados.
-   `require.external.modules` - Array de módulos externos permitidos. Também suporta curingas, então especificar `['@scope/*-ver-??]`, por exemplo, permitirá usar todos os módulos que tenham um nome da forma `@scope/something-ver-aa`, `@scope/other-ver-11`, etc. O curinga `*` não corresponde a separadores de caminho.
-   `require.external.transitive` - Booleano que indica se dependências transitivas de módulos externos são permitidas (padrão: `false`). **AVISO**: Quando um módulo é requisitado transitivamente, qualquer módulo pode então requisitá-lo normalmente, mesmo que isso não fosse possível antes de ser carregado.
-   `require.builtin` - Array de módulos embutidos permitidos, aceita ["\*"] para todos (padrão: nenhum). **AVISO**: "\*" pode ser perigoso, pois novos módulos embutidos podem ser adicionados.
-   `require.root` - Caminho(s) restrito(s) onde módulos locais podem ser requisitados (padrão: todos os caminhos).
-   `require.mock` - Coleção de módulos simulados (tanto externos quanto embutidos).
-   `require.context` - `host` (padrão) para requisitar módulos no host e fazer proxy deles para o sandbox. `sandbox` para carregar, compilar e requisitar módulos no sandbox. `callback(moduleFilename, ext)` para escolher dinamicamente um contexto por módulo. O padrão será sandbox se nada for especificado. Exceto para `events`, módulos embutidos são sempre requisitados no host e passados por proxy para o sandbox.
-   `require.import` - Um array de módulos a serem carregados no NodeVM na inicialização.
-   `require.resolve` - Uma função de busca adicional caso um módulo não seja encontrado em um dos caminhos tradicionais de busca do node.
-   `require.customRequire` - Use em vez da função `require` para carregar módulos do host.
-   `require.strict` - `false` para não forçar o modo estrito em módulos carregados por require (padrão: `true`).
-   `require.fs` - Implementação personalizada do sistema de arquivos.
-   `nesting` - **AVISO**: Permitir isso é um risco de segurança, pois scripts podem criar um NodeVM que pode requisitar qualquer módulo do host. `true` para habilitar aninhamento de VMs (padrão: `false`).
-   `wrapper` - `commonjs` (padrão) para envolver o script no wrapper CommonJS, `none` para recuperar o valor retornado pelo script.
-   `argv` - Array a ser passado para `process.argv`.
-   `env` - Objeto a ser passado para `process.env`.
-   `strict` - `true` para carregar módulos em modo estrito (padrão: `false`).

**IMPORTANTE**: O timeout não é eficaz para o NodeVM, então ele não é imune a `while (true) {}` ou algo semelhante.

**LEMBRE-SE**: Quanto mais módulos você permitir, mais frágil seu sandbox se torna.```js
import { NodeVM } from 'vm2';

const vm = new NodeVM({
	console: 'inherit',
	sandbox: {},
	require: {
		external: true,
		builtin: ['fs', 'path'],
		root: './',
		mock: {
			fs: {
				readFileSync: () => 'Nice try!',
			},
		},
	},
});

// Sync

let functionInSandbox = vm.run('module.exports = function(who) { console.log("hello "+ who); }');
functionInSandbox('world');

// Async

let functionWithCallbackInSandbox = vm.run('module.exports = function(who, callback) { callback("hello "+ who); }');
functionWithCallbackInSandbox('world', greeting => {
	console.log(greeting);
});

Quando wrapper está definido como none, o NodeVM se comporta mais como VM para código síncrono.```js assert.ok(vm.run('return true') === true);

**DICA**: Consulte os testes para mais exemplos de uso.

### Carregando módulos por caminho relativo

Para carregar módulos por caminho relativo, você deve passar o caminho completo do script que está executando como segundo argumento para o método `run` do vm, se o script for uma string. O nome do arquivo é então exibido em qualquer rastreamento de pilha gerado pelo script.```js
vm.run('require("foobar")', '/data/myvmscript.js');

Se o script que você está executando é um VMScript, o caminho é fornecido no construtor do VMScript.```js const script = new VMScript('require("foobar")', { filename: '/data/myvmscript.js' }); vm.run(script);

### Resolver

Um resolver pode ser criado via `makeResolverFromLegacyOptions` e usado para múltiplas instâncias de `NodeVM`, permitindo compartilhar código de módulo compilado, potencialmente acelerando os tempos de carregamento. O primeiro exemplo de `NodeVM` pode ser reescrito usando `makeResolverFromLegacyOptions` da seguinte forma.```js
const resolver = makeResolverFromLegacyOptions({
	external: true,
	builtin: ['fs', 'path'],
	root: './',
	mock: {
		fs: {
			readFileSync: () => 'Nice try!',
		},
	},
});
const vm = new NodeVM({
	console: 'inherit',
	sandbox: {},
	require: resolver,
});

VMScript

Você pode aumentar o desempenho usando scripts pré-compilados. O VMScript pré-compilado pode ser executado várias vezes. É importante observar que o código não está vinculado a nenhuma VM (contexto); em vez disso, ele é vinculado antes de cada execução, apenas para aquela execução.```js import { VM, VMScript } from 'vm2';

const vm = new VM(); const script = new VMScript('Math.random()'); console.log(vm.run(script)); console.log(vm.run(script));

Funciona tanto para `VM` quanto para `NodeVM`.```js
import { NodeVM, VMScript } from 'vm2';

const vm = new NodeVM();
const script = new VMScript('module.exports = Math.random()');
console.log(vm.run(script));
console.log(vm.run(script));

O código é compilado automaticamente na primeira vez que é executado. Pode-se compilar o código a qualquer momento com script.compile(). Uma vez que o código é compilado, o método não tem efeito.

Compiladores

compiler aceita javascript (padrão), typescript, coffeescript ou a sua própria função. Os compiladores typescript e coffeescript são opcionais — instale o pacote você mesmo; o vm2 não depende de nenhum deles.

TypeScript

O compilador typescript integrado requer typescript@6 ou anterior.

O vm2 transpila através da API transpileModule() do TypeScript. O TypeScript 7 removeu-a do ponto de entrada do pacote — require('typescript') aí resolve apenas para { version, versionMajorMinor }, e a API substituta reside nos subcaminhos explicitamente instáveis typescript/unstable/*, nenhum dos quais fornece um equivalente de transpilação de ficheiro único. Portanto, não há nada para o vm2 usar como alternativa no 7.x.

Selecionar compiler: 'typescript' com o TypeScript 7 instalado lança um erro em new VMScript(...) / new VM(...):``` VMError: The installed TypeScript (7.0.2) does not expose the transpileModule() API that vm2's built-in TypeScript compiler uses; it was removed from the package entry point in TypeScript 7. Install typescript@6 or earlier, or pass your own transpiler as a function: { compiler: (code, filename) => javaScriptSource }.

Ou fixe `typescript@6`, ou forneça o seu próprio transpilador — qualquer função que retorne JavaScript funciona, portanto o `tsc` do TypeScript 7, esbuild, swc ou um type-stripper são todos válidos:```js
import { VM, VMScript } from 'vm2';
import { transformSync } from 'esbuild';

const script = new VMScript('const x: number = 1; x', {
	compiler: (code, filename) => transformSync(code, { loader: 'ts', format: 'cjs' }).code,
});

new VM().run(script);

Um compilador personalizado recebe (code, filename) e deve retornar código-fonte JavaScript. Ele é executado no realm do host, antes do sandboxing — trate-o como código confiável e nunca construa um a partir de entrada não confiável.

CoffeeScript

Requer que coffee-script esteja instalado. Compilado com { header: false, bare: true }; quaisquer compilerOptions que você passar serão mescladas sobre esses.

Tratamento de erros

Erros na compilação de código e na execução síncrona de código podem ser tratados com try-catch. Erros na execução assíncrona de código podem ser tratados anexando um manipulador de evento uncaughtException ao process do Node.```js try { var script = new VMScript('Math.random()').compile(); } catch (err) { console.error('Failed to compile script.', err); }

try { vm.run(script); } catch (err) { console.error('Failed to execute script.', err); }

process.on('uncaughtException', err => { console.error('Asynchronous error caught.', err); });

## Depurando código em sandbox

Você pode depurar ou inspecionar código em execução na sandbox como se estivesse rodando em um processo normal.

-   Você pode usar breakpoints (o que exige que você especifique um nome de arquivo de script)
-   Você pode usar a palavra-chave `debugger`.
-   Você pode usar step-in para entrar no código em execução na sandbox.

### Exemplo

/tmp/main.js:```js
import { VM, VMScript } from 'vm2';
import { readFileSync } from 'node:fs';

const file = `${__dirname}/sandbox.js`;

// By providing a file name as second argument you enable breakpoints
const script = new VMScript(readFileSync(file), file);

new VM().run(script);

/tmp/sandbox.js```js const foo = 'ahoj';

// The debugger keyword works just fine everywhere. // Even without specifying a file name to the VMScript object. debugger;

## Objetos somente leitura (experimental)

Para impedir que scripts em sandbox adicionem, alterem ou excluam propriedades dos objetos com proxy, você pode usar os métodos `freeze` para tornar o objeto somente leitura. Isso só é eficaz dentro da VM. Objetos congelados são afetados profundamente. Tipos primitivos não podem ser congelados.

**Exemplo sem usar `freeze`:**```js
const util = {
	add: (a, b) => a + b,
};

const vm = new VM({
	sandbox: { util },
});

vm.run('util.add = (a, b) => a - b');
console.log(util.add(1, 1)); // returns 0

Exemplo com o uso de freeze:```js const vm = new VM(); // Objects specified in the sandbox cannot be frozen. vm.freeze(util, 'util'); // Second argument adds object to global.

vm.run('util.add = (a, b) => a - b'); // Fails silently when not in strict mode. console.log(util.add(1, 1)); // returns 2

**IMPORTANTE:** Não é possível congelar objetos que já foram encaminhados por proxy para a VM.

## Objetos protegidos (experimental)

Ao contrário de `freeze`, este método permite que scripts em sandbox adicionem, alterem ou excluam propriedades em objetos, com uma exceção — não é possível anexar funções. Portanto, scripts em sandbox não conseguem modificar métodos como `toJSON`, `toString` ou `inspect`.

**IMPORTANTE:** Não é possível proteger objetos que já foram encaminhados por proxy para a VM.

## Relações entre sandboxes```js
const assert = require('assert');
const { VM } = require('vm2');

const sandbox = {
	object: new Object(),
	func: new Function(),
	buffer: new Buffer([0x01, 0x05]),
};

const vm = new VM({ sandbox });

assert.ok(vm.run(`object`) === sandbox.object);
assert.ok(vm.run(`object instanceof Object`));
assert.ok(vm.run(`object`) instanceof Object);
assert.ok(vm.run(`object.__proto__ === Object.prototype`));
assert.ok(vm.run(`object`).__proto__ === Object.prototype);

assert.ok(vm.run(`func`) === sandbox.func);
assert.ok(vm.run(`func instanceof Function`));
assert.ok(vm.run(`func`) instanceof Function);
assert.ok(vm.run(`func.__proto__ === Function.prototype`));
assert.ok(vm.run(`func`).__proto__ === Function.prototype);

assert.ok(vm.run(`new func() instanceof func`));
assert.ok(vm.run(`new func()`) instanceof sandbox.func);
assert.ok(vm.run(`new func().__proto__ === func.prototype`));
assert.ok(vm.run(`new func()`).__proto__ === sandbox.func.prototype);

assert.ok(vm.run(`buffer`) === sandbox.buffer);
assert.ok(vm.run(`buffer instanceof Buffer`));
assert.ok(vm.run(`buffer`) instanceof Buffer);
assert.ok(vm.run(`buffer.__proto__ === Buffer.prototype`));
assert.ok(vm.run(`buffer`).__proto__ === Buffer.prototype);
assert.ok(vm.run(`buffer.slice(0, 1) instanceof Buffer`));
assert.ok(vm.run(`buffer.slice(0, 1)`) instanceof Buffer);

CLI

Antes de poder usar o vm2 na linha de comando, instale-o globalmente com npm install vm2 -g.```sh vm2 ./script.js

## Recomendações de endurecimento

O vm2 previne escapes de sandbox (código não confiável obtendo acesso ao realm do host). Ele **não**, por si só, previne todas as formas de esgotamento de recursos ou negação de serviço. Quem incorpora código não confiável deve adicionar as seguintes defesas em camadas ao redor da sandbox.

### 1. Limite a alocação de memória com `bufferAllocLimit`

Uma única chamada `Buffer.alloc(N)` com `N` controlado pelo atacante é executada como uma alocação síncrona em C++ do host que o `timeout` do V8 não consegue interromper. Em ambientes com memória restrita, um payload de sandbox de ~100 bytes pode elevar o RSS do host em 100 MB+ e derrubar o processo do host via OOM. Defina `bufferAllocLimit` (ex.: `32 * 1024 * 1024`) para limitar alocações individuais:```js
const vm = new VM({
	timeout: 1000,
	bufferAllocLimit: 32 * 1024 * 1024,
	allowAsync: false,
});

O limite também se aplica aos caminhos obsoletos Buffer(N) e new Buffer(N). Observe que o esgotamento agregado (muitas alocações pequenas, Buffer.concat, Uint8Array, String.repeat, Array(n).fill(), etc.) não é coberto por esse limite — combine-o com um limite de memória do lado do host (--max-old-space-size, limite de contêiner, cgroup) para cobertura completa.

2. Instale um manipulador `unhandledRejection` no lado do host

Existe uma classe de DoS de abortamento do processo host em que o código da sandbox cria uma async function, async function* ou await using cujo corpo lança um valor que dispara um erro no realm do host durante a formatação da pilha (por exemplo, e.name = Symbol(); e.stack). O V8 cria a promise de rejeição por meio da Promise intrínseca do realm, o que contorna o wrap da subclasse Promise do vm2, então a rejeição escapa para o host como unhandledRejection. No Node 15+, o comportamento padrão é encerrar o processo.

Fechar isso exige alterar o comportamento observável do host, então o vm2 não envia uma correção por padrão. Os incorporadores devem instalar um manipulador no nível do processo que engula (ou registre) as rejeições originadas da sandbox:```js // Recommended: filter rejections that originated inside vm2 and swallow them, // while letting your own host-side rejections propagate. process.on('unhandledRejection', (reason, promise) => { // Heuristic: rejections from the sandbox frequently surface as values // without proper Error semantics, or with stacks pointing at vm.js. // Adjust the predicate to match your application. if (looksLikeSandboxOrigin(reason)) { return; // swallow — don't terminate the process } // Otherwise: handle (or rethrow) as normal for your host code. yourLogger.error('unhandled rejection', reason); });

Se a sua aplicação não tiver outra fonte de rejeições não tratadas, um engolir geral + registo é aceitável:```js
process.on('unhandledRejection', reason => {
	yourLogger.warn('swallowed sandbox rejection', reason);
});

Uma correção direcionada pode ser lançada por trás de um flag opt-in swallowSandboxUnhandledRejections em uma futura versão menor; até lá, o handler do lado do host é a mitigação recomendada.

3. Execute com um limite de memória no nível do processo

Mesmo com bufferAllocLimit definido, execute o processo host com --max-old-space-size (ou um limite de memória de contêiner equivalente) dimensionado para a carga de trabalho. O limite protege contra a primitiva de alocação única; o limite no nível do SO protege contra esgotamento agregado e contra qualquer primitiva de alocação futura que o vm2 ainda não tenha limitado.

4. Trate `require.builtin: ['*']` como uma configuração fora da sandbox

O curinga '*' expande para a maioria dos built-ins do Node, incluindo child_process, fs, dgram, net, http e dns. Essas são primitivas completas de capacidade do host — require('child_process').execSync('id') é alcançável a partir da sandbox sob '*'. A semântica de '*' do vm2 é intencional (alguns embedders executam código confiável, mas isolado), mas não deve ser usada como padrão para código não confiável. Prefira uma allowlist explícita com o menor conjunto de módulos que sua sandbox realmente precisa.

5. `nesting: true` é uma porta de escape

nesting: true permite que o código da sandbox faça require('vm2') e construa NodeVMs aninhadas. A configuração de require da VM aninhada é escolhida pelo código da sandbox que a constrói, não restringida pela VM externa. Concretamente:```js const vm = new NodeVM({ nesting: true, require: { builtin: [] } }); vm.run( const { NodeVM: NVM } = require('vm2'); // Inner VM's config is whatever the sandbox writes here: const inner = new NVM({ require: { builtin: ['child_process'] } }); inner.run('require("child_process").execSync("id")'); // RCE);

Se você definir `nesting: true`, você efetivamente concedeu ao sandbox o mesmo nível de confiança que você tem. **Não habilite `nesting: true` para código não confiável.** Use-o apenas quando você confiar no próprio código em sandbox, mas quiser semântica de execução estilo VM (global limpo, timeouts controlados) por razões não relacionadas à segurança.

`nesting: true` **exige um objeto de configuração `require` explícito** (ex.: `require: { builtin: [] }` ou `require: {}`). Qualquer outra forma — `require: false`, `require: undefined`, `require: null`, ou omitir `require` completamente — lança `VMError` na construção (GHSA-m4wx-m65x-ghrr, substitui GHSA-8hg8-63c5-gwmx). Todas essas formas produzem um resolver somente-NESTING_OVERRIDE: o sandbox pode `require('vm2')` mas nada mais, o que é uma primitiva de escape pura sem uso legítimo. Para negar todos os requires, remova `nesting: true`. Para permitir VMs aninhadas, forneça uma configuração `require` explícita para que a compensação seja visível no local da chamada.

## Problemas Conhecidos

-   Não é possível definir uma classe que estenda uma classe com proxy. Isso inclui usar uma classe com proxy em `Object.create`.
-   `eval` direto não funciona.
-   Registrar arrays do sandbox no log repetirá a parte do array nas propriedades.
-   As transformações do código-fonte podem resultar em uma string de origem diferente para uma função.
-   Existem maneiras de travar o processo do node de dentro do sandbox. Consulte [Recomendações de endurecimento](#hardening-recommendations).
-   O compilador `typescript` embutido não funciona com TypeScript 7 ou mais recente, que removeu a API `transpileModule()` que o vm2 usa. Use `typescript@6` ou passe seu próprio transpilador — consulte [Compiladores](#compilers).

[npm-image]: https://img.shields.io/npm/v/vm2.svg
[npm-url]: https://www.npmjs.com/package/vm2
[license-image]: https://img.shields.io/npm/l/vm2.svg
[license-url]: https://raw.githubusercontent.com/patriksimek/vm2/resurrection/LICENSE.md
[downloads-image]: https://img.shields.io/npm/dm/vm2.svg
[downloads-url]: https://www.npmjs.com/package/vm2
[snyk-image]: https://snyk.io/test/github/patriksimek/vm2/badge.svg
[snyk-url]: https://snyk.io/test/github/patriksimek/vm2

Ler mais

vm2 v3.11.6

Categorias