信頼できない JavaScript コードの実行

重要: これは JavaScript と TypeScript コードの実行についてのみ説明します。そうは言っても、この記述は、他のコードを他の言語で実行する方向にもなるかもしれません。

ユーザーがアプリケーション内でコードを実行できるようにすると、カスタマイズと機能の世界が開かれますが、プラットフォームが重大なセキュリティ上の脅威にさらされることにもなります。

これが ユーザー コードであることを考えると、サーバーの停止 (無限ループの可能性があります) から機密情報の窃取まで、あらゆることが予想されます。

この記事では、Web ワーカー、静的コード分析など、ユーザー コードの実行を軽減するためのさまざまな戦略について説明します。

あなたは気にする必要があります

CodeSandbox や StackBiltz のような共同開発環境から、 January のようなカスタマイズ可能な API プラットフォームに至るまで、ユーザーが提供したコードを実行する必要があるシナリオは数多くあります。コードのプレイグラウンドですらリスクにさらされます。

つまり、ユーザーが提供したコードを安全に実行することの 2 つの重要な利点は次のとおりです。

1. ユーザーの信頼の獲得: ユーザーが信頼できる場合でも、他の悪意のある人からコピーしたコードを実行する可能性があります。
2. 環境を保護します。サーバーを停止するコードは絶対に必要ありません。 (true) {} ながら考える

「機密情報」を定義する

ユーザー コードの実行は、一部のデータが盗まれる可能性があることを懸念するまでは害はありません。あなたが懸念しているデータはすべて機密情報とみなされます。たとえば、ほとんどの場合、JWT は機密情報です (おそらく認証メカニズムとして使用される場合)

何が問題になる可能性がありますか

リクエストごとに送信される Cookie に保存された JWT の潜在的なリスクを考慮してください。ユーザーが誤って JWT を悪意のあるサーバーに送信するリクエストをトリガーしてしまう可能性があります...

• クロスサイト スクリプティング (XSS)。
• サービス拒否 (DoS) 攻撃。
• データの漏洩。適切な保護策がなければ、これらの脅威はアプリケーションの整合性とパフォーマンスを損なう可能性があります。

メソッド

邪悪な評価

すべての中で最も単純ですが、最も危険です。

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

このコードを実行すると、そのメッセージが記録されます。基本的に、eval はグローバル/ウィンドウ スコープにアクセスできる JS インタープリターです。

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

このコードは、グローバル スコープで定義されたフェッチを使用します。インタプリタはそれについて知りませんが、eval はウィンドウにアクセスできるため、知っています。これは、ブラウザでの eval の実行は、サーバー環境やワーカーでの実行とは異なることを意味します。

eval(`document.body`);

これはどうでしょうか...

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

このコードはブラウザのタブを停止します。なぜユーザーが自分自身にこのようなことをするのか疑問に思うかもしれません。そうですね、彼らはインターネットからコードをコピーしているのかもしれません。そのため、実行をタイムボックス化して静的分析を行うことが推奨されます。

eval については MDN ドキュメントを確認してください

タイム ボックスの実行は、Web ワーカーでコードを実行し、setTimeout を使用して実行時間を制限することで実行できます。

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) {}');

関数コンストラクター

これは eval に似ていますが、外側のスコープにアクセスできないため、少し安全です。

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

このコードは 2 を記録します。

注: 2 番目の引数は関数本体です。

関数コンストラクターは外側のスコープにアクセスできないため、次のコードはエラーをスローします。

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

ただし、グローバル スコープにはアクセスできるため、上記のフェッチ例は機能します。

ウェブワーカー

WebWorker 上で Function Constructor と eval を実行できます。これは、DOM アクセスがないため、少し安全です。

さらに制限を設けるには、fetch、XMLHttpRequest、sendBeacon などのグローバル オブジェクトの使用を禁止することを検討してください。その方法については、この記事を確認してください。

分離された VM

Isolated-VM は、別の VM (v8 の Isolate インターフェイス) でコードを実行できるようにするライブラリです

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

このコードは hello world を記録します

Webアセンブリ

これは、コードを実行するためのサンドボックス環境を提供するため、興味深いオプションです。注意点の 1 つは、JavaScript バインディングを備えた環境が必要であるということです。しかし、Extism と呼ばれる興味深いプロジェクトがそれを促進します。彼らのチュートリアルに従うとよいでしょう。

興味深いのは、「eval」を使用してコードを実行することですが、WebAssembly の性質上、DOM、ネットワーク、ファイル システム、およびホスト環境へのアクセスが不可能であることです (ただし、これらは環境によって異なる場合があります)。 wasm ランタイム)。

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

以上が信頼できない JavaScript コードの実行の詳細内容です。詳細については、PHP 中国語 Web サイトの他の関連記事を参照してください。