Drošas JavaScript smilškastes izveide ar ES6 moduļiem un globalThis

GlobalThis apgūšana programmā JavaScript drošai konteksta izolācijai

Rakstot JavaScript kodu, kas mijiedarbojas ar ārējām vai neuzticamām ievadēm, ir obligāti jānovērš nesankcionēta piekļuve globālajam objektam. Tas garantē jūsu apkārtnes drošību un konsekvenci. Viena mūsdienu globālās darbības jomas kontroles metode ir, izmantojot globalJavaScript ir salīdzinoši jauna funkcionalitāte, ko sauc par šo objektu.

The visā pasaulē Neatkarīgi no tā, vai viņi izmanto Node.js vai pārlūkprogrammu, izstrādātāji var piekļūt globālajam kontekstam dažādās vidēs. objektu. Būtiski, starptautiskā, jo šī ir pārkonfigurējams, smilškastes vai kontrolētas izpildes vides var izveidot, īslaicīgi to pārrakstot.

Izstrādātāji var izolēt koda izpildi, izmantojot šo funkcionalitāti, kas ir īpaši noderīga, strādājot ar neuzticamām ievadēm. Mēs varam ievietot kodu smilškastē, izveidojot unikālu globālu kontekstu, kas ļaus piekļūt tikai iepriekš noteiktai mainīgo kopai, vienlaikus novēršot globālā objekta pārējo daļu.

Šajā rakstā tiks apspriests, kā to izmantot globālaisTas un ES6 moduļi, lai izveidotu smilšu kasti. Es parādīšu koncepcijas pierādījumu, kas īslaicīgi aizstāj globālo kontekstu, lai garantētu drošu koda izpildi regulētā vidē.

Droša globāla konteksta izveide, izmantojot ES6 moduļus un globalThis

Piedāvāto skriptu galvenais mērķis ir nodrošināt a smilšu kastes vide kur globālais objekts (globālaisTas) tiek uz laiku aizstāts. Šī metode ļauj paslēpt svarīgus mainīgos vai rekvizītus no sākotnējā globālā objekta, kas ir ļoti noderīgi, strādājot ar ārēju vai neuzticamu kodu. Pārdefinējot globālo tvērumu, tiek nodrošināta labāka mainīgā piekļuves kontrole, būtībā ierobežojot kodu, lai piekļūtu tikai smilšu kastē deklarētajiem rekvizītiem.

Oriģināla saglabāšana globālaisTas lokālajā mainīgajā (saglabātsGlobal) ir pirmais solis procesā pirmajā piemērā. Tas ir svarīgs solis, jo pēc smilškastes koda izpildes tiks atjaunots globālais konteksts. Aizstājot globālo kontekstu ar jaunu objektu (šeit, myContext), skripts cenšas izgūt mainīgos (šeit, a un b), kas atrodas šajā smilšu kastē. Kā parādīts pirmajā minētajā numurā, ja nav norādīti noteikti mainīgie, tiek parādīta atsauces kļūda. Visbeidzot, beidzot bloks nodrošina, ka izpildes laikā vienmēr tiek atjaunots globālais konteksts, izvairoties no neparedzētām sekām citās lietojumprogrammas jomās.

Otrā pieeja izmanto a Starpniekserveris iebilst šīs procedūras uzlabošanai. Programmā JavaScript starpniekserveris ļauj programmētājiem pārinterpretēt un pārtvert darbības, kas veiktas ar objektiem. Šajā skriptā starpniekserveris pārrauga īpašuma piekļuves pieprasījumus un nosaka, vai vēlamais rekvizīts atrodas smilškastes objektā. A Atsauces kļūda tiek izmests gadījumā, ja īpašumu nevar atrast, garantējot, ka nav pieejami ārējie mainīgie. Šī iemesla dēļ tā ir lieliska iespēja nodrošināt globālo tvērumu un pārvaldīt mainīgo piekļuvi dinamiskā smilškastes iestatījumā.

Lai pilnībā izolētu smilškastes izpildi, trešais skripts izmanto IIFE (tūlīt izsauktās funkcijas izteiksme). Ārējam kodam ir grūti piekļūt globālajam kontekstam vai iejaukties tajā, jo IIFE modelis aptver visu darbību savā lokālajā tvērumā. Šī metode ir drošāka, jo globalThis nav pakļauts ārpasaulei un tiek mainīts tikai IIFE ietvaros. Garantējot, ka viss smilškastes kods darbojas pilnībā nošķirtā vidē, tas uzlabo drošību un skripta darbības konsekvenci.

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

Pielāgota globālā konteksta izmantošanas paplašināšana JavaScript smilškastē

Vēl viens ieguvums no nodarbinātības globalTā saderība ar daudziem kontekstiem, piemēram, tīmekļa pārlūkprogrammām un servera puses sistēmām, piemēram, Node.js, ir šāda. smilškastes situācijā. Būtībā jūs novirzāt sava koda uzsvaru uz kontrolētu mainīgo kolekciju, kad globālo objektu pārrakstāt ar pielāgotu kontekstu, kā parādīts mūsu piemērā. Palaižot neuzticamus trešo pušu skriptus vai atdalot dažādus lielas tiešsaistes lietojumprogrammas moduļus, šī stratēģija var būt īpaši noderīga, lai novērstu mainīgo lielumu savstarpēju inficēšanos.

Vēl viens būtisks elements ir fakts, ka ES6 moduļu sistēmai JavaScript ir iebūvētas tvēruma noteikšanas metodes, kas daļēji atdala mainīgos. No otras puses, izmantojot globāls, ļaujot mums pārvaldīt visu globālo situāciju, tas ļauj mums iet tālāk par to. Neļaujot skriptiem, kuriem tam nevajadzētu piekļūt, redzēt sākotnējo globālo kontekstu, tas ne tikai pastiprina drošību, bet arī palīdz novērst netīšu globālo mainīgo pārrakstīšanu. Šī metode labi darbojas, lai aizsargātu lietotnes no ļaunprātīga vai nepareizi rakstīta koda.

Apvienojot ES6 moduļus ar Starpniekserveri vēl vairāk uzlabo drošību situācijās, kad nepieciešama precīza kontrole pār to, kuriem jūsu lietojumprogrammas komponentiem ir piekļuve globālajam objektam. Filtrējot piekļuvi noteiktiem rekvizītiem globālajā objektā, starpniekserveri ļauj nodrošināt, ka var piekļūt tikai atļautajiem rekvizītiem. Katra īrnieka dati vairāku īrnieku lietojumprogrammā ir pilnībā jānodala no pārējo īrnieku datiem. Šis risinājums ir mērogojams un pielāgojams dažādiem lietošanas gadījumiem.