Ausführen von nicht vertrauenswürdigem JavaScript-Code

WICHTIG: Hier geht es nur um die Ausführung von JavaScript- und TypeScript-Code. Abgesehen davon könnte das Schreiben auch die Richtung sein, anderen Code in anderen Sprachen auszuführen.

Wenn Sie Benutzern erlauben, ihren Code innerhalb Ihrer Anwendung auszuführen, eröffnet sich eine Welt der Anpassung und Funktionalität, aber es setzt Ihre Plattform auch erheblichen Sicherheitsbedrohungen aus.

Angesichts der Tatsache, dass es sich um Benutzercode handelt, ist alles zu erwarten, vom Anhalten der Server (es könnte sich um Endlosschleifen handeln) bis zum Diebstahl vertraulicher Informationen.

In diesem Artikel werden verschiedene Strategien zur Eindämmung der Ausführung von Benutzercode untersucht, darunter Web Worker, statische Codeanalyse und mehr …

Es sollte Sie interessieren

Es gibt viele Szenarien, in denen Sie vom Benutzer bereitgestellten Code ausführen müssen, von kollaborativen Entwicklungsumgebungen wie CodeSandbox und StackBiltz bis hin zu anpassbaren API-Plattformen wie January. Sogar Code-Spielplätze sind anfällig für Risiken.

Die beiden wesentlichen Vorteile der sicheren Ausführung von vom Benutzer bereitgestelltem Code sind nämlich:

1. Das Vertrauen Ihres Benutzers gewinnen: Auch wenn der Benutzer vertrauenswürdig ist, kann er Code ausführen, der von anderen absichtlich schlechten Personen kopiert wurde.
2. Sichern Sie Ihre Umgebung: Das Letzte, was Sie brauchen, ist ein Code, der Ihren Server anhält. Denken Sie während (wahr) {}

Definieren Sie „Sensible Informationen“

Das Ausführen von Benutzercode ist erst dann schädlich, wenn Sie befürchten, dass dadurch Daten gestohlen werden könnten. Alle Daten, um die Sie sich Sorgen machen, gelten als vertrauliche Informationen. Beispielsweise handelt es sich bei JWT in den meisten Fällen um vertrauliche Informationen (vielleicht wenn sie als Authentifizierungsmechanismus verwendet werden)

Was könnte schief gehen

Berücksichtigen Sie die potenziellen Risiken von JWT, die in Cookies gespeichert werden, die bei jeder Anfrage gesendet werden. Ein Benutzer könnte versehentlich eine Anfrage auslösen, die das JWT an einen bösartigen Server sendet, und...

• Cross-Site Scripting (XSS).
• Denial of Service (DoS)-Angriffe.
• Datenexfiltration. Ohne angemessene Schutzmaßnahmen können diese Bedrohungen die Integrität und Leistung Ihrer Anwendung beeinträchtigen.

Methoden

Die böse Bewertung

Das Einfachste von allen und doch das Riskanteste.

eval('console.log("I am dangerous!")');

Wenn Sie diesen Code ausführen, wird diese Nachricht protokolliert. Im Wesentlichen ist eval ein JS-Interpreter, der auf den globalen/Fensterbereich zugreifen kann.

const res = await eval('fetch(`https://jsonplaceholder.typicode.com/users`)');
const users = await res.json();

Dieser Code verwendet Fetch, der im globalen Bereich definiert ist. Der Interpreter weiß nichts davon, aber da eval auf ein Fenster zugreifen kann, weiß er es. Das bedeutet, dass sich die Ausführung einer Auswertung im Browser von der Ausführung in einer Serverumgebung oder einem Worker unterscheidet.

eval(`document.body`);

Wie wäre es damit...

eval(`while (true) {}`);

Dieser Code stoppt den Browser-Tab. Sie fragen sich vielleicht, warum ein Benutzer sich das antun würde. Nun, sie kopieren möglicherweise Code aus dem Internet. Aus diesem Grund empfiehlt es sich, eine statische Analyse mit/oder einer zeitlichen Begrenzung der Ausführung durchzuführen.

Vielleicht möchten Sie sich die MDN-Dokumente zum Thema Evaluierung ansehen

Die Ausführung der Zeitbox kann erfolgen, indem der Code in einem Web-Worker ausgeführt wird und setTimeout verwendet wird, um die Ausführungszeit zu begrenzen.

async function timebox(code, timeout = 5000) {
  const worker = new Worker('user-runner-worker.js');
  worker.postMessage(code);

  const timerId = setTimeout(() => {
    worker.terminate();
    reject(new Error('Code execution timed out'));
  }, timeout);

  return new Promise((resolve, reject) => {
    worker.onmessage = event => {
      clearTimeout(timerId);
      resolve(event.data);
    };
    worker.onerror = error => {
      clearTimeout(timerId);
      reject(error);
    };
  });
}

await timebox('while (true) {}');

Funktionskonstruktor

Dies ähnelt eval, ist jedoch etwas sicherer, da es nicht auf den umschließenden Bereich zugreifen kann.

const userFunction = new Function('param', 'console.log(param);');
userFunction(2);

Dieser Code protokolliert 2.

Hinweis: Das zweite Argument ist der Funktionskörper.

Der Funktionskonstruktor kann nicht auf den umschließenden Bereich zugreifen, sodass der folgende Code einen Fehler auslöst.

function fnConstructorCannotUseMyScope() {
  let localVar = 'local value';
  const userFunction = new Function('return localVar');
  return userFunction();
}

Aber es kann auf den globalen Bereich zugreifen, sodass das Abrufbeispiel von oben funktioniert.

WebWorker

Sie können „Function Constructor and eval“ auf einem WebWorker ausführen, was aufgrund der Tatsache, dass es keinen DOM-Zugriff gibt, etwas sicherer ist.

Um weitere Einschränkungen einzuführen, sollten Sie erwägen, die Verwendung globaler Objekte wie fetch, XMLHttpRequest und sendBeacon zu verbieten. Sehen Sie sich in diesem Artikel an, wie Sie das tun können.

Isolierte VM

Isolated-VM ist eine Bibliothek, die es Ihnen ermöglicht, Code in einer separaten VM (der Isolate-Schnittstelle von v8) auszuführen

import ivm from 'isolated-vm';

const code = `count += 5;`;

const isolate = new ivm.Isolate({ memoryLimit: 32 /* MB */ });
const script = isolate.compileScriptSync(code);
const context = isolate.createContextSync();

const jail = context.global;
jail.setSync('log', console.log);

context.evalSync('log("hello world")');

Dieser Code protokolliert Hallo Welt

WebAssembly

Dies ist eine spannende Option, da sie eine Sandbox-Umgebung zum Ausführen von Code bietet. Eine Einschränkung besteht darin, dass Sie eine Umgebung mit Javascript-Bindungen benötigen. Ein interessantes Projekt namens Extism erleichtert dies jedoch. Vielleicht möchten Sie ihrem Tutorial folgen.

Das Faszinierende daran ist, dass Sie eval verwenden, um den Code auszuführen, aber aufgrund der Natur von WebAssembly sind DOM, Netzwerk, Dateisystem und Zugriff auf die Host-Umgebung nicht möglich (obwohl sie je nach Modell unterschiedlich sein können). die WASM-Laufzeit).

function evaluate() {
  const { code, input } = JSON.parse(Host.inputString());
  const func = eval(code);
  const result = func(input).toString();
  Host.outputString(result);
}

module.exports = { evaluate };

You'll have to compile the above code first using Extism, which will output a Wasm file that can be run in an environment that has Wasm-runtime (browser or node.js).

const message = {
  input: '1,2,3,4,5',
  code: `
        const sum = (str) => str
          .split(',')
          .reduce((acc, curr) => acc + parseInt(curr), 0);
        module.exports = sum;
`,
};

// continue running the wasm file

Docker

We're now moving to the server-side, Docker is a great option to run code in an isolation from the host machine. (Beware of container escape)

You can use dockerode to run the code in a container.

import Docker from 'dockerode';
const docker = new Docker();

const code = `console.log("hello world")`;
const container = await docker.createContainer({
  Image: 'node:lts',
  Cmd: ['node', '-e', code],
  User: 'node',
  WorkingDir: '/app',
  AttachStdout: true,
  AttachStderr: true,
  OpenStdin: false,
  AttachStdin: false,
  Tty: true,
  NetworkDisabled: true,
  HostConfig: {
    AutoRemove: true,
    ReadonlyPaths: ['/'],
    ReadonlyRootfs: true,
    CapDrop: ['ALL'],
    Memory: 8 * 1024 * 1024,
    SecurityOpt: ['no-new-privileges'],
  },
});

Keep in mind that you need to make sure the server has docker installed and running. I'd recommend having a separate server dedicated only to this that acts as a pure-function server.

Moreover, you might benefit from taking a look at sysbox, a VM-like container runtime that provides a more secure environment. Sysbox is worth it, especially if the main app is running in a container, which means that you'll be running Docker in Docker.

This was the method of choice at January but soon enough, the language capabilities mandated more than passing the code through the container shell. Besides, for some reason, the server memory spikes frequently; we run the code inside self-removable containers on every 1s debounced keystroke. (You can do better!)

Other options

• Web Containers
• MicroVM (Firecraker)
• Deno subhosting
• Wasmer
• ShadowRealms

Safest option

I'm particularly fond of Firecracker, but it’s a bit of work to set up, so if you cannot afford the time yet, you want to be on the safe side, do a combination of static analysis and time-boxing execution. You can use esprima to parse the code and check for any malicious act.

How to run TypeScript code?

Well, same story with one (could be optional) extra step: Transpile the code to JavaScript before running it. Simply put, you can use esbuild or typescript compiler, then continue with the above methods.

async function build(userCode: string) {
  const result = await esbuild.build({
    stdin: {
      contents: `${userCode}`,
      loader: 'ts',
      resolveDir: __dirname,
    },
    inject: [
      // In case you want to inject some code
    ],
    platform: 'node',
    write: false,
    treeShaking: false,
    sourcemap: false,
    minify: false,
    drop: ['debugger', 'console'],
    keepNames: true,
    format: 'cjs',
    bundle: true,
    target: 'es2022',
    plugins: [
      nodeExternalsPlugin(), // make all the non-native modules external
    ],
  });
  return result.outputFiles![0].text;
}

Notes:

• Rust-based bundlers usually offer a web assembly version, which means you can transpile the code in the browser. Esbuild does have a web assembly version.
• Don't include user specified imports into the bundle unless you've allow-listed them.

Additionally, you can avoid transpiling altogether by running the code using Deno or Bun in a docker container since they support TypeScript out of the box.

Conclusion

Running user code is a double-edged sword. It can provide a lot of functionality and customization to your platform, but it also exposes you to significant security risks. It’s essential to understand the risks and take appropriate measures to mitigate them and remember that the more isolated the environment, the safer it is.

References

• January instant compilation
• Running untrusted JavaScript in Node.js
• How do languages support executing untrusted user code at runtime?
• Safely Evaluating JavaScript with Context Data

Das obige ist der detaillierte Inhalt vonAusführen von nicht vertrauenswürdigem JavaScript-Code. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!