Biztonságos JavaScript Sandbox létrehozása ES6 modulokkal és globalThis-vel

A globalThis elsajátítása JavaScriptben a biztonságos kontextus elkülönítéshez

Feltétlenül meg kell akadályozni a globális objektumhoz való jogosulatlan hozzáférést, amikor olyan JavaScript-kódot ír, amely kölcsönhatásba lép külső vagy nem megbízható bemenetekkel. Ez garantálja a környezet biztonságát és egységességét. A globális hatókör szabályozásának egyik kortárs módszere a A globalJavaScript egy viszonylag új funkcióval rendelkezik, az úgynevezett objektum.

A világszerte Függetlenül attól, hogy Node.js-t vagy böngészőt használnak, a fejlesztők ezzel a globális kontextushoz környezetileg is hozzáférhetnek objektum. Lényeges, nemzetközi, mert ez újrakonfigurálható, ideiglenes felülírásával sandboxok vagy ellenőrzött végrehajtási környezetek hozhatók létre.

A fejlesztők elkülöníthetik a kódvégrehajtást ezzel a funkcióval, ami különösen akkor hasznos, ha nem megbízható bemenetekkel dolgoznak. A kódot homokozóba helyezhetjük úgy, hogy egyedi globális kontextust hozunk létre, amely csak a változók előre meghatározott készletéhez teszi lehetővé a hozzáférést, miközben megakadályozza a globális objektum többi részének kitettségét.

Ez a cikk a használat módját tárgyalja globálisEz és ES6 modulok homokozó felépítéséhez. Bemutatok egy olyan koncepciót, amely egy pillanatra felváltja a globális környezetet, hogy garantálja a biztonságos kódvégrehajtást szabályozott környezetben.

Biztonságos globális kontextus kialakítása az ES6 modulokkal és a globalThis-vel

A kínált szkriptek elsődleges célja, hogy a homokozós környezet ahol a globális objektum (globálisEz) ideiglenesen lecserélődik. Ezzel a módszerrel rejtve tarthatja az eredeti globális objektum fontos változóit vagy tulajdonságait, ami nagyon hasznos, ha külső vagy nem megbízható kóddal dolgozik. A globális hatókör újradefiniálása biztosítja a változók hozzáférésének jobb szabályozását, mivel lényegében korlátozza a kódot, hogy csak a sandboxban deklarált tulajdonságokhoz férhessen hozzá.

Az eredeti mentése globálisEz egy helyi változóba (mentveGlobal) a folyamat első lépése az első példában. Ez azért fontos lépés, mert a sandbox kód végrehajtása után a globális kontextus visszaáll. A globális kontextus lecserélésekor egy új objektumra (itt, myContext), a szkript megpróbálja lekérni a változókat (itt, a és b) található ebben a homokozóban. Amint azt az első számban említettük, hivatkozási hiba lép fel, ha bizonyos változók nincsenek megadva. Végül a végül blokk gondoskodik arról, hogy végrehajtáskor a globális kontextus mindig visszaálljon, elkerülve az alkalmazás más területeire gyakorolt ​​váratlan hatásokat.

A második megközelítés a Meghatalmazott kifogásolják ennek az eljárásnak a javítását. A JavaScriptben a proxy lehetővé teszi a programozók számára, hogy újraértelmezzék és elfogják az objektumokon végrehajtott műveleteket. Ezen a szkripten belül a proxy figyeli a tulajdonság-hozzáférési kérelmeket, és meghatározza, hogy a kívánt tulajdonság megtalálható-e a sandbox objektumban. A ReferenceError kidobásra kerül abban az esetben, ha az ingatlan nem található, garantálva, hogy semmilyen külső változó nem érhető el. Emiatt kiváló lehetőség a globális hatókör biztosítására és a változó hozzáférések kezelésére egy dinamikus sandbox-beállításban.

A sandbox-végrehajtás teljes elkülönítése érdekében a harmadik szkript egy IIFE-t (azonnal meghívott függvénykifejezést) használ. A külső kód nehezen fér hozzá a globális kontextushoz, vagy zavarja meg azt, mivel az IIFE minta a teljes műveletet a saját helyi hatókörébe burkolja. Ez a módszer biztonságosabb, mert a globalThis nincs kitéve a külvilágnak, és csak az IIFE-n belül módosul. Azzal, hogy garantálja, hogy az összes sandbox-kód teljesen elkülönített környezetben működjön, fokozza a szkript működésének biztonságát és következetességét.

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

Az egyéni globális kontextus használatának kiterjesztése a JavaScript Sandboxingban

A foglalkoztatás másik előnye globalEz a kompatibilitás számos környezettel, például webböngészőkkel és szerveroldali rendszerekkel, mint például a Node.js homokozó szituációban. Lényegében a kód hangsúlyát egy ellenőrzött változógyűjteményre irányítja át, amikor felülírja a globális objektumot egy egyéni kontextussal, ahogy a példánkban is látható. Nem megbízható, harmadik féltől származó szkriptek futtatásakor vagy egy nagy online alkalmazás különálló moduljainak szétválasztásakor ez a stratégia különösen hasznos lehet a változók keresztszennyeződésének megelőzésében.

Az a tény, hogy a JavaScript ES6 modulrendszere beépített hatókör-meghatározási technikákkal rendelkezik, amelyek részben elválasztják a változókat, egy másik kulcsfontosságú elem. Másrészt használva globális Azáltal, hogy lehetővé tesszük a teljes globális helyzet irányítását, ez lehetővé teszi számunkra, hogy ezen túllépjünk. Azáltal, hogy megakadályozza, hogy a hozzá nem férő szkriptek lássák az eredeti globális kontextust, ez nemcsak a biztonságot erősíti, hanem segít megelőzni a globális változók nem szándékos felülírását is. Ez a módszer jól működik az alkalmazások rosszindulatú vagy rosszul megírt kódokkal szembeni védelmében.

Az ES6 modulok kombinálása a Proxyk tovább javítja a biztonságot olyan helyzetekben, amikor finoman szabályozni kell, hogy az alkalmazás mely összetevői férhessenek hozzá a globális objektumhoz. A globális objektumon belüli adott tulajdonságokhoz való hozzáférés szűrésével a proxyk biztosítják, hogy csak az engedélyezett tulajdonságok legyenek elérhetők. Az egyes bérlők adatait egy többbérlős alkalmazásban teljesen el kell különíteni a többi bérlő adataitól. Ez a megoldás skálázható és adaptálható különféle felhasználási esetekhez.