Erstellen einer sicheren JavaScript-Sandbox mit ES6-Modulen und globalThis

Beherrschung des globalen This in JavaScript für sichere Kontextisolierung

Beim Schreiben von JavaScript-Code, der mit externen oder nicht vertrauenswürdigen Eingaben interagiert, ist es unbedingt erforderlich, unbefugten Zugriff auf das globale Objekt zu verhindern. Dies garantiert die Sicherheit und Konsistenz Ihrer Umgebung. Eine zeitgenössische Methode zur Kontrolle des globalen Umfangs ist die globalJavaScript verfügt über eine relativ neue Funktionalität namens this Objekt.

Der WeltweitUnabhängig davon, ob sie Node.js oder einen Browser verwenden, können Entwickler damit umgebungsübergreifend auf den globalen Kontext zugreifen Objekt. Entscheidend ist, internationalWeil das Ist rekonfigurierbar, können durch vorübergehendes Überschreiben Sandboxen oder kontrollierte Ausführungsumgebungen erstellt werden.

Entwickler können mit dieser Funktionalität die Codeausführung isolieren, was besonders nützlich ist, wenn mit nicht vertrauenswürdigen Eingaben gearbeitet wird. Wir können den Code sandboxen, indem wir einen eindeutigen globalen Kontext einrichten, der nur den Zugriff auf einen vorgegebenen Satz von Variablen ermöglicht und gleichzeitig verhindert, dass der Rest des globalen Objekts offengelegt wird.

In diesem Artikel wird die Verwendung erläutert globalThis und ES6-Module zum Aufbau einer Sandbox. Ich werde einen Proof of Concept demonstrieren, der vorübergehend den globalen Kontext ersetzt, um eine sichere Codeausführung in einer regulierten Umgebung zu gewährleisten.

Aufbau eines sicheren globalen Kontexts mit ES6-Modulen und globalThis

Das Hauptziel der angebotenen Skripte ist die Bereitstellung eines Sandbox-Umgebung wobei das globale Objekt (globalThis) wird vorübergehend ersetzt. Mit dieser Methode können Sie wichtige Variablen oder Eigenschaften des ursprünglichen globalen Objekts verbergen, was sehr hilfreich ist, wenn Sie mit externem oder nicht vertrauenswürdigem Code arbeiten. Durch die Neudefinition des globalen Bereichs wird eine bessere Kontrolle über den Variablenzugriff gewährleistet, indem der Code im Wesentlichen auf den Zugriff auf die in der Sandbox deklarierten Eigenschaften beschränkt wird.

Speichern des Originals globalThis in eine lokale Variable (gespeichertGlobal) ist der erste Schritt im Prozess im ersten Beispiel. Dies ist ein wichtiger Schritt, da der globale Kontext wiederhergestellt wird, sobald der Sandbox-Code ausgeführt wird. Beim Ersetzen des globalen Kontexts durch ein neues Objekt (hier meinKontext), versucht das Skript, Variablen abzurufen (hier A Und B) befindet sich in dieser Sandbox. Wie in der ersten erwähnten Ausgabe gezeigt, wird ein Referenzfehler ausgelöst, wenn bestimmte Variablen nicht angegeben werden. Schließlich die Endlich Der Block stellt sicher, dass bei der Ausführung der globale Kontext immer wiederhergestellt wird, wodurch unerwartete Auswirkungen auf andere Bereiche der Anwendung vermieden werden.

Der zweite Ansatz nutzt a Stellvertreter Einspruch gegen eine Verbesserung dieses Verfahrens einlegen. In JavaScript ermöglicht ein Proxy Programmierern, an Objekten ausgeführte Aktionen neu zu interpretieren und abzufangen. Innerhalb dieses Skripts überwacht der Proxy Anforderungen für den Zugriff auf Eigenschaften und ermittelt, ob die gewünschte Eigenschaft im Sandbox-Objekt vorhanden ist. A Referenzfehler wird ausgelöst, wenn die Eigenschaft nicht gefunden werden kann, wodurch sichergestellt wird, dass auf keine externen Variablen zugegriffen werden kann. Aus diesem Grund ist es eine starke Option zur Sicherung des globalen Bereichs und zur Verwaltung des Variablenzugriffs in einer dynamischen Sandbox-Umgebung.

Um die Sandbox-Ausführung vollständig zu isolieren, verwendet das dritte Skript einen IIFE (Immediately Invoked Function Expression). Für externen Code ist es schwierig, auf den globalen Kontext zuzugreifen oder ihn zu stören, da das IIFE-Muster die gesamte Aktion in seinen eigenen lokalen Bereich einschließt. Diese Methode ist sicherer, da globalThis ist nicht der Außenwelt ausgesetzt und wird nur innerhalb des IIFE verändert. Durch die Gewährleistung, dass der gesamte Sandbox-Code in einer vollständig getrennten Umgebung ausgeführt wird, werden die Sicherheit und Konsistenz des Skriptbetriebs erhöht.

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

Erweiterung der Verwendung von benutzerdefiniertem globalen Kontext beim JavaScript-Sandboxing

Ein weiterer Vorteil der Beschäftigung GlobalDies ist die Kompatibilität mit vielen Kontexten wie Webbrowsern und serverseitigen Systemen wie Node.js in einer Sandbox-Situation. Im Wesentlichen verlagern Sie den Schwerpunkt Ihres Codes auf eine kontrollierte Sammlung von Variablen, wenn Sie das globale Objekt mit einem benutzerdefinierten Kontext überschreiben, wie in unserem Beispiel gezeigt. Wenn Sie nicht vertrauenswürdige Skripts von Drittanbietern ausführen oder verschiedene Module einer großen Online-Anwendung trennen, kann diese Strategie besonders hilfreich sein, um eine Kreuzkontamination von Variablen zu verhindern.

Ein weiteres entscheidendes Element ist die Tatsache, dass das ES6-Modulsystem in JavaScript über integrierte Scoping-Techniken verfügt, die Variablen teilweise trennen. Andererseits die Verwendung globalIndem wir die gesamte globale Situation steuern können, ist dies der Fall ermöglicht es uns, darüber hinauszugehen. Indem verhindert wird, dass Skripte, die nicht darauf zugreifen können, den ursprünglichen globalen Kontext sehen, erhöht dies nicht nur die Sicherheit, sondern hilft auch, unbeabsichtigtes Überschreiben globaler Variablen zu verhindern. Diese Methode eignet sich gut zum Schutz von Apps vor bösartigem oder schlecht geschriebenem Code.

Kombination von ES6-Modulen mit Proxys verbessert die Sicherheit noch weiter in Situationen, in denen Sie eine detaillierte Kontrolle darüber benötigen, welche Komponenten Ihrer Anwendung Zugriff auf das globale Objekt haben. Indem Sie den Zugriff auf bestimmte Eigenschaften innerhalb des globalen Objekts filtern, können Sie mit Proxys sicherstellen, dass nur auf zulässige Eigenschaften zugegriffen werden kann. Die Daten jedes Mandanten in einer mandantenfähigen Anwendung müssen vollständig von den Daten der anderen Mandanten getrennt sein. Diese Lösung ist skalierbar und an verschiedene Anwendungsfälle anpassbar.