Creación de un Sandbox seguro de JavaScript con módulos ES6 y globalThis

Dominar globalThis en JavaScript para un aislamiento seguro del contexto

Es imperativo evitar el acceso no autorizado al objeto global al escribir código JavaScript que interactúa con entradas externas o que no son de confianza. Esto garantiza la seguridad y coherencia de su entorno. Un método contemporáneo de controlar el alcance global es a través de la globalJavaScript tiene una funcionalidad relativamente nueva llamada esta objeto.

El en todo el mundoIndependientemente de si utilizan Node.js o un navegador, los desarrolladores pueden acceder al contexto global de forma transambiental con este objeto. Fundamentalmente, internacionalPorque esto es reconfigurable, se pueden crear entornos sandbox o de ejecución controlada sobrescribiéndolo temporalmente.

Los desarrolladores pueden aislar la ejecución del código con esta funcionalidad, que resulta especialmente útil cuando se trabaja con entradas que no son de confianza. Podemos proteger el código estableciendo un contexto global único, que solo permitirá el acceso a un conjunto predeterminado de variables y al mismo tiempo evitará la exposición al resto del objeto global.

Este artículo discutirá cómo usar globalEsto y módulos ES6 para construir un sandbox. Demostraré una prueba de concepto que reemplaza momentáneamente el contexto global para garantizar la ejecución segura del código en un entorno regulado.

Construyendo un contexto global seguro con módulos ES6 y globalThis

El objetivo principal de los guiones que se ofrecen es proporcionar una entorno de espacio aislado donde el objeto global (globalEsto) se reemplaza temporalmente. Este método le permite mantener ocultas variables o propiedades importantes del objeto global original, lo cual es muy útil cuando se trabaja con código externo o que no es de confianza. Redefinir el alcance global garantiza un mejor control sobre el acceso a las variables al limitar esencialmente el código para acceder solo a las propiedades declaradas en el sandbox.

Guardando el original globalEsto en una variable local (guardadoGlobal) es el primer paso del proceso en el primer ejemplo. Este es un paso importante porque, una vez que se realiza el código de espacio aislado, se restaurará el contexto global. Al reemplazar el contexto global con un nuevo objeto (aquí, miContexto), el script intenta recuperar variables (aquí, a y b) situado dentro de esta zona de pruebas. Como se demostró en el primer número mencionado, se genera un error de referencia si no se especifican ciertas variables. Por último, el finalmente block se asegura de que, tras la ejecución, el contexto global siempre se restablezca, evitando efectos inesperados en otras áreas de la aplicación.

El segundo enfoque hace uso de un Apoderado objeto de mejorar este procedimiento. En JavaScript, un proxy permite a los programadores reinterpretar e interceptar acciones realizadas sobre objetos. Dentro de este script, el Proxy monitorea las solicitudes de acceso a la propiedad y determina si la propiedad deseada está presente en el objeto sandbox. A Error de referencia se lanza en caso de que no se pueda localizar la propiedad, garantizando que no se pueda acceder a variables externas. Debido a esto, es una opción sólida para proteger el alcance global y administrar el acceso a variables en una configuración de espacio aislado dinámico.

Para aislar completamente la ejecución de la zona de pruebas, el tercer script emplea una IIFE (Expresión de función invocada inmediatamente). Es difícil que el código externo acceda al contexto global o interfiera con él porque el patrón IIFE envuelve toda la acción dentro de su propio alcance local. Este método es más seguro porque el globalThis no está expuesto al mundo exterior y sólo se modifica dentro del IIFE. Al garantizar que todo el código aislado funcione en un entorno completamente segregado, se mejora la seguridad y la coherencia en el funcionamiento del 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);

Ampliando el uso del contexto global personalizado en el sandboxing de JavaScript

Otro beneficio de emplear globalSu compatibilidad con muchos contextos, como navegadores web y sistemas del lado del servidor como Node.js, es esto en una situación de sandboxing. En esencia, estás redirigiendo el énfasis de tu código a una colección controlada de variables cuando sobrescribes el objeto global con un contexto personalizado, como se demuestra en nuestro ejemplo. Cuando se ejecutan scripts de terceros que no son de confianza o se separan módulos distintos de una aplicación en línea de gran tamaño, esta estrategia puede resultar especialmente útil para evitar la contaminación cruzada de variables.

El hecho de que el sistema de módulos ES6 en JavaScript tenga técnicas de alcance integradas que separan parcialmente las variables es otro elemento crucial. Por otra parte, utilizando globalAl permitirnos gobernar la situación global completa, este nos permite ir más allá. Al evitar que los scripts que no deberían poder acceder a él vean el contexto global original, esto no solo fortalece la seguridad sino que también ayuda a evitar sobrescrituras involuntarias de variables globales. Este método funciona bien para proteger aplicaciones de códigos maliciosos o mal escritos.

Combinando módulos ES6 con apoderados mejora aún más la seguridad en situaciones en las que necesita un control detallado sobre qué componentes de su aplicación tienen acceso al objeto global. Al filtrar el acceso a propiedades específicas dentro del objeto global, los servidores proxy le permiten asegurarse de que solo se pueda acceder a las propiedades permitidas. Los datos de cada inquilino en una aplicación multiinquilino deben estar completamente separados de los datos de los demás inquilinos. Esta solución es escalable y adaptable a diversos casos de uso.