Skapa en säker JavaScript-sandlåda med ES6-moduler och globalThis

Bemästra det globala Detta i JavaScript för säker kontextisolering

Det är absolut nödvändigt att förhindra obehörig åtkomst till det globala objektet när du skriver JavaScript-kod som interagerar med externa eller opålitliga indata. Detta garanterar säkerheten och konsistensen i din omgivning. En modern metod för att kontrollera global räckvidd är via globalJavaScript har en relativt ny funktion som kallas detta objekt.

De över hela världen Oavsett om de använder Node.js eller en webbläsare kan utvecklare komma åt det globala sammanhanget över hela miljön med detta objekt. Avgörande, internationellt eftersom detta är omkonfigurerbar, kan sandlådor eller kontrollerade exekveringsmiljöer skapas genom att temporärt skriva över det.

Utvecklare kan isolera kodexekvering med denna funktion, vilket är särskilt användbart när man arbetar med otillförlitliga indata. Vi kan sandboxa koden genom att skapa ett unikt globalt sammanhang, som endast tillåter åtkomst till en förutbestämd uppsättning variabler samtidigt som vi förhindrar exponering för resten av det globala objektet.

Den här artikeln kommer att diskutera hur man använder globalt detta och ES6-moduler för att bygga en sandlåda. Jag ska visa ett proof of concept som tillfälligt ersätter det globala sammanhanget för att garantera säker kodexekvering i en reglerad miljö.

Bygga ett säkert globalt sammanhang med ES6-moduler och globalThis

Det primära målet med de manus som erbjuds är att tillhandahålla en sandlådemiljö där det globala objektet (globalt detta) ersätts tillfälligt. Den här metoden låter dig hålla viktiga variabler eller egenskaper från det ursprungliga globala objektet dolda, vilket är mycket användbart när du arbetar med extern eller opålitlig kod. Omdefiniering av det globala omfånget säkerställer bättre kontroll över variabel åtkomst genom att i huvudsak begränsa koden till att endast komma åt de egenskaper som deklareras i sandlådan.

Sparar originalet globalt detta till en lokal variabel (sparade Global) är det första steget i processen i det första exemplet. Detta är ett viktigt steg eftersom, när sandlådekoden har utförts, kommer det globala sammanhanget att återställas. När det globala sammanhanget ersätts med ett nytt objekt (här, myContext), strävar skriptet efter att hämta variabler (här, a och b) belägen i denna sandlåda. Som visas i det första numret som nämnts uppstår ett referensfel om vissa variabler inte specificeras. Slutligen slutligen block ser till att det globala sammanhanget alltid återställs vid körning, vilket undviker oväntade effekter på andra delar av programmet.

Det andra tillvägagångssättet använder sig av en Ombud invända mot att förbättra detta förfarande. I JavaScript gör en proxy det möjligt för programmerare att omtolka och avlyssna åtgärder som vidtas på objekt. Inom det här skriptet övervakar proxyn begäranden om egendomsåtkomst och avgör om den önskade egenskapen finns i sandlådeobjektet. A Referensfel kastas i händelse av att fastigheten inte kan lokaliseras, vilket garanterar att inga externa variabler är tillgängliga. På grund av detta är det ett starkt alternativ för att säkra det globala omfånget och hantera variabel åtkomst i en dynamisk sandlådemiljö.

För att fullständigt isolera sandlådekörningen använder det tredje skriptet en IIFE (Immediately Invoked Function Expression). Det är svårt för extern kod att komma åt eller störa det globala sammanhanget eftersom IIFE-mönstret lindar in hela handlingen inom sitt eget lokala omfång. Denna metod är säkrare eftersom den globala Detta är inte utsatt för omvärlden och ändras endast inom IIFE. Genom att garantera att all sandlådekod fungerar i en helt segregerad miljö, ökar det säkerheten och konsekvensen i skriptets funktion.

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

Utöka användningen av anpassad global kontext i JavaScript-sandboxning

Ytterligare en fördel med att anställa global Dess kompatibilitet med många sammanhang, såsom webbläsare och server-side system som Node.js, är detta i en sandlådesituation. I huvudsak dirigerar du om tyngdpunkten i din kod till en kontrollerad samling av variabler när du skriver över det globala objektet med en anpassad kontext, som visas i vårt exempel. När man kör opålitliga skript från tredje part eller separerar distinkta moduler i en stor onlineapplikation kan denna strategi vara särskilt användbar för att förhindra korskontaminering av variabler.

Det faktum att ES6-modulsystemet i JavaScript har inbyggda scoping-tekniker som delvis separerar variabler är ett annat avgörande element. Å andra sidan använder man global Genom att tillåta oss att styra hela den globala situationen, detta gör det möjligt för oss att gå längre än detta. Genom att förhindra skript som inte borde kunna komma åt det från att se det ursprungliga globala sammanhanget, stärker detta inte bara säkerheten utan hjälper också till att förhindra oavsiktliga överskrivningar av globala variabler. Den här metoden fungerar bra för att skydda appar från skadlig eller felskriven kod.

Kombinera ES6-moduler med Proxies förbättrar säkerheten ytterligare i situationer där du behöver finkornig kontroll över vilka komponenter i din applikation som har tillgång till det globala objektet. Genom att filtrera åtkomst till specifika egenskaper inom det globala objektet, låter proxyservrar dig se till att endast egenskaper som är tillåtna kan nås. Uppgifterna för varje hyresgäst i en applikation med flera hyresgäster måste vara helt åtskilda från uppgifterna från de andra hyresgästerna. Denna lösning är skalbar och anpassningsbar till olika användningsfall.