Een veilige JavaScript-sandbox creëren met ES6-modules en globalThis

Beheersing van het globalThis in JavaScript voor veilige contextisolatie

Het is absoluut noodzakelijk om ongeautoriseerde toegang tot het globale object te voorkomen bij het schrijven van JavaScript-code die interageert met externe of niet-vertrouwde invoer. Dit garandeert de veiligheid en consistentie van uw omgeving. Een hedendaagse methode om de mondiale reikwijdte te beheersen is via de globalJavaScript heeft een relatief nieuwe functionaliteit genaamd deze voorwerp.

De wereldwijdOngeacht of ze Node.js of een browser gebruiken, ontwikkelaars kunnen hiermee cross-environmenteel toegang krijgen tot de mondiale context voorwerp. Cruciaal is dat internationaalOmdat dit is herconfigureerbaar, sandboxes of gecontroleerde uitvoeringsomgevingen kunnen worden gemaakt door deze tijdelijk te overschrijven.

Ontwikkelaars kunnen met deze functionaliteit de uitvoering van code isoleren, wat vooral handig is bij het werken met niet-vertrouwde invoer. We kunnen de code in een sandbox plaatsen door een unieke mondiale context tot stand te brengen, die alleen toegang tot een vooraf bepaalde reeks variabelen mogelijk maakt, terwijl blootstelling aan de rest van het globale object wordt voorkomen.

In dit artikel wordt besproken hoe u het kunt gebruiken globaalDit en ES6-modules om een ​​sandbox te bouwen. Ik zal een proof of concept demonstreren dat tijdelijk de mondiale context vervangt om veilige code-uitvoering in een gereguleerde omgeving te garanderen.

Bouwen aan een veilige mondiale context met ES6-modules en globalThis

Het primaire doel van de aangeboden scripts is het bieden van een sandbox-omgeving waar het globale object (globaalDit) wordt tijdelijk vervangen. Met deze methode kunt u belangrijke variabelen of eigenschappen van het oorspronkelijke globale object verborgen houden, wat erg handig is als u met externe of niet-vertrouwde code werkt. Het opnieuw definiëren van de globale reikwijdte zorgt voor een betere controle over de toegang tot variabelen, door de code feitelijk te beperken tot alleen toegang tot de eigenschappen die in de sandbox zijn gedeclareerd.

Het origineel opslaan globaalDit in een lokale variabele (opgeslagenGlobaal) is de eerste stap in het proces in het eerste voorbeeld. Dit is een belangrijke stap omdat, zodra de code in de sandbox is uitgevoerd, de globale context zal worden hersteld. Bij het vervangen van de globale context door een nieuw object (hier mijnContext), probeert het script variabelen op te halen (hier A En B) in deze sandbox. Zoals aangetoond in het eerste genoemde probleem, ontstaat er een referentiefout als bepaalde variabelen niet worden gespecificeerd. Tenslotte de Eindelijk block zorgt ervoor dat bij uitvoering de globale context altijd wordt hersteld, waardoor onverwachte effecten op andere delen van de applicatie worden vermeden.

De tweede benadering maakt gebruik van a Volmacht bezwaar maken tegen het verbeteren van deze procedure. In JavaScript stelt een proxy programmeurs in staat acties die op objecten worden uitgevoerd, opnieuw te interpreteren en te onderscheppen. Binnen dit script bewaakt de proxy aanvragen voor toegang tot eigendommen en bepaalt of de gewenste eigenschap aanwezig is in het sandboxobject. A ReferentieFout wordt gegenereerd in het geval dat de woning niet kan worden gelokaliseerd, waardoor wordt gegarandeerd dat er geen externe variabelen toegankelijk zijn. Hierdoor is het een sterke optie voor het veiligstellen van de mondiale reikwijdte en het beheren van variabele toegang in een dynamische sandbox-omgeving.

Om de uitvoering van de sandbox volledig te isoleren, maakt het derde script gebruik van een IIFE (Immediately Invoked Function Expression). Het is moeilijk voor externe code om toegang te krijgen tot de mondiale context of deze te verstoren, omdat het IIFE-patroon de hele actie binnen zijn eigen lokale reikwijdte wikkelt. Deze methode is veiliger omdat de globalThis wordt niet blootgesteld aan de buitenwereld en wordt alleen binnen de IIFE gewijzigd. Door te garanderen dat alle code in een sandbox in een volledig gescheiden omgeving werkt, wordt de veiligheid en consistentie van de werking van het script verbeterd.

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

Uitbreiding van het gebruik van aangepaste globale context in JavaScript-sandboxing

Nog een voordeel van in dienst nemen globalDe compatibiliteit met veel contexten, zoals webbrowsers en server-side systemen zoals Node.js, is dit in een sandbox-situatie. In wezen verlegt u de nadruk van uw code naar een gecontroleerde verzameling variabelen wanneer u het globale object overschrijft met een aangepaste context, zoals gedemonstreerd in ons voorbeeld. Bij het uitvoeren van niet-vertrouwde scripts van derden of het scheiden van afzonderlijke modules van een grote online applicatie, kan deze strategie vooral nuttig zijn bij het voorkomen van kruisbesmetting van variabelen.

Het feit dat het ES6-modulesysteem in JavaScript ingebouwde scopingtechnieken heeft die variabelen gedeeltelijk scheiden, is een ander cruciaal element. Aan de andere kant: gebruiken mondiaalDoor ons in staat te stellen de volledige mondiale situatie te beheersen, dit stelt ons in staat verder te gaan dan dit. Door te voorkomen dat scripts die er geen toegang toe zouden moeten hebben, de oorspronkelijke mondiale context kunnen zien, wordt niet alleen de beveiliging versterkt, maar wordt ook het onbedoeld overschrijven van globale variabelen voorkomen. Deze methode werkt goed om apps te beschermen tegen kwaadaardige of slecht geschreven code.

ES6-modules combineren met Volmachten verbetert de beveiliging nog verder in situaties waarin u fijnmazige controle nodig heeft over welke componenten van uw applicatie toegang hebben tot het globale object. Door de toegang tot specifieke eigenschappen binnen het globale object te filteren, zorgen proxy's ervoor dat alleen de toegestane eigenschappen toegankelijk zijn. De gegevens van elke tenant in een multi-tenanttoepassing moeten volledig gescheiden zijn van de gegevens van de andere tenants. Deze oplossing is schaalbaar en aanpasbaar aan verschillende gebruiksscenario's.