Création d'un bac à sable JavaScript sécurisé avec les modules ES6 et globalThis

Maîtriser le globalThis en JavaScript pour une isolation sécurisée du contexte

Il est impératif d'empêcher tout accès non autorisé à l'objet global lors de l'écriture de code JavaScript qui interagit avec des entrées externes ou non fiables. Cela garantit la sécurité et la cohérence de votre environnement. Une méthode contemporaine de contrôle de la portée mondiale consiste à utiliser globalJavaScript a une fonctionnalité relativement nouvelle appelée ceci objet.

Le dans le monde entierQu'ils utilisent Node.js ou un navigateur, les développeurs peuvent accéder au contexte global de manière inter-environnementale grâce à ce objet. Surtout, internationalParce que cela est reconfigurable, des bacs à sable ou des environnements d'exécution contrôlés peuvent être créés en l'écrasant temporairement.

Les développeurs peuvent isoler l'exécution du code grâce à cette fonctionnalité, ce qui est particulièrement utile lorsqu'ils travaillent avec des entrées non fiables. Nous pouvons mettre le code en sandbox en établissant un contexte global unique, qui permettra uniquement l'accès à un ensemble prédéterminé de variables tout en empêchant l'exposition au reste de l'objet global.

Cet article expliquera comment utiliser globalThis et des modules ES6 pour construire un bac à sable. Je vais démontrer une preuve de concept qui remplace momentanément le contexte global pour garantir une exécution de code sécurisée dans un cadre réglementé.

Construire un contexte mondial sécurisé avec les modules ES6 et globalThis

L'objectif principal des scripts proposés est de fournir un environnement en bac à sable où l'objet global (globalThis) est temporairement remplacé. Cette méthode vous permet de masquer les variables ou propriétés importantes de l’objet global d’origine, ce qui est très utile lorsque vous travaillez avec du code externe ou non fiable. La redéfinition de la portée globale garantit un meilleur contrôle sur l'accès aux variables en limitant essentiellement le code à accéder uniquement aux propriétés déclarées dans le bac à sable.

Sauvegarder l'original globalThis dans une variable locale (enregistréGlobal) est la première étape du processus dans le premier exemple. Il s’agit d’une étape importante car, une fois le code sandboxé exécuté, le contexte global sera restauré. En remplaçant le contexte global par un nouvel objet (ici, monContexte), le script tente de récupérer des variables (ici, un et b) situé dans ce bac à sable. Comme démontré dans le premier problème mentionné, une erreur de référence est générée si certaines variables ne sont pas spécifiées. Enfin, le enfin block garantit que, lors de l'exécution, le contexte global est toujours restauré, évitant ainsi tout effet inattendu sur d'autres zones de l'application.

La deuxième approche utilise un Procuration s'opposer à l'amélioration de cette procédure. En JavaScript, un proxy permet aux programmeurs de réinterpréter et d'intercepter les actions entreprises sur les objets. Dans ce script, le proxy surveille les demandes d'accès aux propriétés et détermine si la propriété souhaitée est présente dans l'objet sandbox. UN Erreur de référence est lancé dans le cas où la propriété ne peut pas être localisée, garantissant qu'aucune variable externe n'est accessible. Pour cette raison, il s’agit d’une option solide pour sécuriser la portée globale et gérer l’accès aux variables dans un environnement sandbox dynamique.

Afin d'isoler complètement l'exécution du bac à sable, le troisième script utilise une IIFE (Immediately Invoked Function Expression). Il est difficile pour le code externe d'accéder au contexte global ou d'interférer avec celui-ci, car le modèle IIFE enveloppe l'intégralité de l'action dans sa propre portée locale. Cette méthode est plus sûre car le globalThis n’est pas exposé au monde extérieur et n’est modifié qu’au sein de l’IIFE. En garantissant que tout le code en bac à sable fonctionne dans un environnement entièrement séparé, il améliore la sécurité et la cohérence du fonctionnement du 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);

Extension de l'utilisation du contexte global personnalisé dans le sandboxing JavaScript

Un autre avantage de l'emploi globalSa compatibilité avec de nombreux contextes, tels que les navigateurs Web et les systèmes côté serveur comme Node.js, est-ce dans une situation de bac à sable. Essentiellement, vous redirigez l'accent de votre code vers une collection contrôlée de variables lorsque vous écrasez l'objet global par un contexte personnalisé, comme le montre notre exemple. Lors de l'exécution de scripts tiers non fiables ou de la séparation de modules distincts d'une grande application en ligne, cette stratégie peut s'avérer particulièrement utile pour empêcher la contamination croisée des variables.

Le fait que le système de modules ES6 en JavaScript dispose de techniques de cadrage intégrées qui séparent partiellement les variables est un autre élément crucial. D’un autre côté, en utilisant globalEn nous permettant de gouverner l’ensemble de la situation mondiale, cela nous permet d'aller au-delà. En empêchant les scripts qui ne devraient pas pouvoir y accéder de voir le contexte global d'origine, cela renforce non seulement la sécurité, mais permet également d'éviter les écrasements involontaires de variables globales. Cette méthode fonctionne bien pour protéger les applications contre le code malveillant ou mal écrit.

Combinant les modules ES6 avec Procurations améliore encore davantage la sécurité dans les situations où vous avez besoin d'un contrôle précis sur les composants de votre application qui ont accès à l'objet global. En filtrant l'accès à des propriétés spécifiques au sein de l'objet global, les proxys vous permettent de vous assurer que seules les propriétés autorisées sont accessibles. Les données de chaque locataire dans une application multi-tenant doivent être complètement séparées des données des autres locataires. Cette solution est évolutive et adaptable à différents cas d’usage.