Oprettelse af en sikker JavaScript-sandbox med ES6-moduler og globalThis

Mestring af det globale Dette i JavaScript til sikker kontekstisolering

Det er bydende nødvendigt at forhindre uautoriseret adgang til det globale objekt, når du skriver JavaScript-kode, der interagerer med eksterne eller ikke-pålidelige input. Dette garanterer sikkerheden og sammenhængen i dine omgivelser. En moderne metode til at kontrollere globalt omfang er via globalJavaScript har en relativt ny funktionalitet kaldet dette objekt.

De på verdensplan Uanset om de bruger Node.js eller en browser, kan udviklere få adgang til den globale kontekst på tværs af miljøet med denne objekt. Afgørende, internationalt, fordi dette er rekonfigurerbar, kan sandkasser eller kontrollerede udførelsesmiljøer laves ved midlertidigt at overskrive det.

Udviklere kan isolere kodekørsel med denne funktionalitet, hvilket er særligt nyttigt, når der arbejdes med input, der ikke er tillid til. Vi kan sandboxe koden ved at etablere en unik global kontekst, som kun vil tillade adgang til et forudbestemt sæt af variabler og samtidig forhindre eksponering for resten af ​​det globale objekt.

Denne artikel vil diskutere, hvordan du bruger globalt dette og ES6-moduler til at konstruere en sandkasse. Jeg vil demonstrere et proof of concept, der midlertidigt erstatter den globale kontekst for at garantere sikker kodeudførelse i et reguleret miljø.

Opbygning af en sikker global kontekst med ES6-moduler og globalThis

Det primære mål med de scripts, der tilbydes, er at give en miljø med sandkasse hvor det globale objekt (globalt dette) erstattes midlertidigt. Denne metode lader dig holde vigtige variabler eller egenskaber fra det originale globale objekt skjult, hvilket er meget nyttigt, når du arbejder med ekstern eller upålidelig kode. Omdefinering af det globale omfang sikrer bedre kontrol over variabel adgang ved i det væsentlige at begrænse koden til kun at få adgang til de egenskaber, der er erklæret i sandkassen.

Gemmer originalen globalt dette ind i en lokal variabel (gemt Global) er det første trin i processen i det første eksempel. Dette er et vigtigt skridt, fordi den globale kontekst vil blive gendannet, når først sandbox-koden er udført. Ved at erstatte den globale kontekst med et nyt objekt (her, minKontekst), forsøger scriptet at hente variabler (her, -en og b) beliggende i denne sandkasse. Som vist i det første nævnte nummer, opstår der en referencefejl, hvis visse variabler ikke er specificeret. Til sidst endelig blok sørger for, at den globale kontekst altid gendannes ved udførelse, hvilket undgår uventede effekter på andre områder af applikationen.

Den anden tilgang gør brug af en Fuldmagt gøre indsigelse mod at forbedre denne procedure. I JavaScript gør en proxy det muligt for programmører at genfortolke og opsnappe handlinger, der udføres på objekter. Inden for dette script overvåger proxyen anmodninger om egenskabsadgang og bestemmer, om den ønskede egenskab er til stede i sandkasseobjektet. EN Referencefejl kastes i tilfælde af, at ejendommen ikke kan lokaliseres, hvilket garanterer, at ingen eksterne variabler er tilgængelige. På grund af dette er det en stærk mulighed for at sikre det globale omfang og administrere variabel adgang i en dynamisk sandkasseindstilling.

For fuldstændigt at isolere sandkasseudførelsen anvender det tredje script en IIFE (Immediately Invoked Function Expression). Det er svært for ekstern kode at få adgang til eller forstyrre den globale kontekst, fordi IIFE-mønsteret omslutter hele handlingen inden for sit eget lokale omfang. Denne metode er mere sikker, fordi den globale er ikke udsat for omverdenen og ændres kun inden for IIFE. Ved at garantere, at al sandbox-kode fungerer i et fuldstændigt adskilt miljø, øger det sikkerheden og ensartetheden i scriptets drift.

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

Udvidelse af brugen af ​​tilpasset global kontekst i JavaScript-sandboxing

Endnu en fordel ved at ansætte global Dens kompatibilitet med mange sammenhænge, ​​såsom webbrowsere og server-side systemer som Node.js, er dette i en sandboxing situation. I bund og grund omdirigerer du vægten af ​​din kode til en kontrolleret samling af variabler, når du overskriver det globale objekt med en tilpasset kontekst, som vist i vores eksempel. Når du kører upålidelige tredjepartsscripts eller adskiller særskilte moduler i en stor onlineapplikation, kan denne strategi være særlig nyttig til at forhindre krydskontaminering af variabler.

Det faktum, at ES6-modulsystemet i JavaScript har indbyggede scoping-teknikker, der delvist adskiller variabler, er et andet afgørende element. På den anden side bruger globalt Ved at tillade os at styre den fulde globale situation, dette sætter os i stand til at gå ud over dette. Ved at forhindre scripts, der ikke burde have adgang til det, i at se den originale globale kontekst, styrker dette ikke kun sikkerheden, men hjælper også med at forhindre utilsigtede overskrivninger af globale variabler. Denne metode fungerer godt til at beskytte apps mod ondsindet eller dårligt skrevet kode.

Kombinerer ES6 moduler med Fuldmagter forbedrer sikkerheden yderligere i situationer, hvor du har brug for finmasket kontrol over, hvilke komponenter i din applikation, der har adgang til det globale objekt. Ved at filtrere adgang til specifikke egenskaber i det globale objekt, giver proxyer dig mulighed for at sikre, at kun egenskaber, der er tilladt, kan tilgås. Dataene for hver lejer i en multi-lejer-applikation skal være fuldstændig adskilt fra dataene for de andre lejere. Denne løsning er skalerbar og kan tilpasses forskellige brugssager.