Criando um Sandbox JavaScript seguro com módulos ES6 e globalThis

Dominando o globalThis em JavaScript para isolamento seguro de contexto

É imperativo impedir o acesso não autorizado ao objeto global ao escrever código JavaScript que interage com entradas externas ou não confiáveis. Isso garante a segurança e consistência do seu entorno. Um método contemporâneo de controlar o escopo global é através do globalJavaScript tem uma funcionalidade relativamente nova chamada isto objeto.

O em todo o mundoIndependentemente de estarem usando Node.js ou um navegador, os desenvolvedores podem acessar o contexto global de forma interambiental com este objeto. Crucialmente, internacionalPorque isso é reconfigurável, sandboxes ou ambientes de execução controlados podem ser criados substituindo-o temporariamente.

Os desenvolvedores podem isolar a execução de código com esta funcionalidade, o que é particularmente útil ao trabalhar com entradas não confiáveis. Podemos colocar o código em sandbox estabelecendo um contexto global exclusivo, que permitirá apenas o acesso a um conjunto predeterminado de variáveis, evitando a exposição ao restante do objeto global.

Este artigo discutirá como usar globalIsso e módulos ES6 para construir uma sandbox. Demonstrarei uma prova de conceito que substitui momentaneamente o contexto global para garantir a execução segura do código em um ambiente regulamentado.

Construindo um Contexto Global Seguro com Módulos ES6 e globalThis

O objetivo principal dos scripts oferecidos é fornecer uma ambiente em área restrita onde o objeto global (globalIsso) é substituído temporariamente. Este método permite manter ocultas variáveis ​​ou propriedades importantes do objeto global original, o que é muito útil ao trabalhar com código externo ou não confiável. A redefinição do escopo global garante melhor controle sobre o acesso às variáveis, limitando essencialmente o código para acessar apenas as propriedades declaradas na sandbox.

Salvando o original globalIsso em uma variável local (salvoGlobal) é a primeira etapa do processo no primeiro exemplo. Esta é uma etapa importante porque, uma vez executado o código em sandbox, o contexto global será restaurado. Ao substituir o contexto global por um novo objeto (aqui, meuContexto), o script tenta recuperar variáveis ​​(aqui, um e b) situado nesta caixa de areia. Conforme demonstrado na primeira questão mencionada, um erro de referência é gerado se determinadas variáveis ​​não forem especificadas. Por último, o finalmente block garante que, na execução, o contexto global seja sempre restaurado, evitando efeitos inesperados em outras áreas da aplicação.

A segunda abordagem faz uso de um Procuração tem por objectivo melhorar este procedimento. Em JavaScript, um proxy permite que os programadores reinterpretem e interceptem ações executadas em objetos. Dentro desse script, o Proxy monitora solicitações de acesso à propriedade e determina se a propriedade desejada está presente no objeto sandbox. UM Erro de referência é lançado caso a propriedade não possa ser localizada, garantindo que nenhuma variável externa esteja acessível. Por isso, é uma opção forte para proteger o escopo global e gerenciar o acesso variável em uma configuração de sandbox dinâmica.

Para isolar completamente a execução do sandbox, o terceiro script emprega um IIFE (Immediately Invoked Function Expression). É difícil para o código externo acessar ou interferir no contexto global porque o padrão IIFE envolve toda a ação dentro de seu próprio escopo local. Este método é mais seguro porque o globalThis não está exposto ao mundo exterior e só é alterado dentro do IIFE. Ao garantir que todo o código em sandbox opere em um ambiente totalmente segregado, aumenta a segurança e a consistência na operação do script.

let myContext = { a: 1, b: 2 };
let f = () => {
    let savedGlobal = globalThis;  // Save the original globalThis
    globalThis = myContext;        // Overwrite globalThis with the sandbox context
    try {
        let result = a + b;         // Attempt to access a and b within the sandbox
        return result;              // Return the calculated result
    } catch (e) {
        console.error(e);           // Catch errors, such as reference errors
    } finally {
        globalThis = savedGlobal;   // Restore the original global context
    }
};
console.log(f());

const myContext = { a: 1, b: 2 };
const sandboxHandler = {
    get: (target, prop) => {
        if (prop in target) {
            return target[prop];
        } else {
            throw new ReferenceError(\`Property \${prop} is not defined\`);
        }
    }
};
let mySandbox = new Proxy(myContext, sandboxHandler);
let f = () => {
    let savedGlobal = globalThis;
    globalThis = mySandbox;           // Overwrite with sandbox proxy
    try {
        let result = a + b;           // Access sandbox variables safely
        return result;
    } catch (e) {
        console.error(e);
    } finally {
        globalThis = savedGlobal;      // Restore global context
    }
};
console.log(f());

((globalThis) => {
    const myContext = { a: 1, b: 2 };
    const f = () => {
        let result = myContext.a + myContext.b;  // Access sandbox variables directly
        return result;
    };
    console.log(f());                // Log the result of the sandboxed function
})(globalThis);

Expandindo o uso de contexto global personalizado em sandboxing JavaScript

Outro benefício de contratar globalSua compatibilidade com muitos contextos, como navegadores da web e sistemas do lado do servidor como Node.js, é esta em uma situação de sandbox. Em essência, você está redirecionando a ênfase do seu código para uma coleção controlada de variáveis ​​ao substituir o objeto global por um contexto personalizado, conforme demonstrado em nosso exemplo. Ao executar scripts de terceiros não confiáveis ​​ou separar módulos distintos de um grande aplicativo online, essa estratégia pode ser especialmente útil na prevenção da contaminação cruzada de variáveis.

O fato de o sistema de módulos ES6 em JavaScript possuir técnicas de escopo integradas que separam parcialmente as variáveis ​​é outro elemento crucial. Por outro lado, usando globalAo permitir-nos governar toda a situação global, este nos permite ir além disso. Ao impedir que scripts que não deveriam ser capazes de acessá-lo vejam o contexto global original, isso não apenas fortalece a segurança, mas também ajuda a evitar substituições não intencionais de variáveis ​​globais. Este método funciona bem para proteger aplicativos contra códigos maliciosos ou mal escritos.

Combinando módulos ES6 com Proxies melhora ainda mais a segurança em situações em que você precisa de controle detalhado sobre quais componentes do seu aplicativo têm acesso ao objeto global. Ao filtrar o acesso a propriedades específicas dentro do objeto global, os proxies permitem garantir que somente as propriedades permitidas possam ser acessadas. Os dados de cada inquilino numa aplicação multi-inquilino precisam de ser completamente segregados dos dados dos outros inquilinos. Esta solução é escalonável e adaptável a vários casos de uso.