Menjalankan Kod JavaScript Tidak Dipercayai

PENTING: Ini mengenai menjalankan kod JavaScript dan TypeScript sahaja. Walaupun begitu, tulisan itu juga mungkin menjadi arahan untuk menjalankan kod lain dalam bahasa lain.

Membenarkan pengguna melaksanakan kod mereka dalam aplikasi anda membuka dunia penyesuaian dan kefungsian, namun ia turut mendedahkan platform anda kepada ancaman keselamatan yang ketara.

Memandangkan ia adalah kod pengguna, segala-galanya dijangka, daripada menghentikan pelayan (ia boleh menjadi gelung infiniti) kepada mencuri maklumat sensitif.

Artikel ini akan meneroka pelbagai strategi untuk mengurangkan kod pengguna yang dijalankan, termasuk Pekerja Web, analisis kod statik dan banyak lagi…

Awak patut ambil berat

Terdapat banyak senario di mana anda perlu menjalankan kod yang disediakan pengguna, daripada persekitaran pembangunan kolaboratif seperti CodeSandbox dan StackBiltz kepada platform API yang boleh disesuaikan seperti Januari. Malah taman permainan kod terdedah kepada risiko.

Iaitu, dua kelebihan penting untuk menjalankan kod yang disediakan pengguna dengan selamat ialah:

1. Mendapat kepercayaan pengguna anda: Walaupun pengguna boleh dipercayai, mereka mungkin melaksanakan kod yang disalin daripada orang lain yang sangat jahat.
2. Lindungi persekitaran anda: perkara terakhir yang anda perlukan ialah sekeping kod yang menghentikan pelayan anda. Fikir sementara (benar) {}

Tentukan "Maklumat sensitif"

Menjalankan kod pengguna tidak berbahaya sehingga anda bimbang perkara ini mungkin menyebabkan beberapa data dicuri. Apa sahaja data yang anda bimbangkan akan dianggap sebagai maklumat sensitif. Sebagai contoh, dalam kebanyakan kes, JWT ialah maklumat sensitif (mungkin apabila digunakan sebagai mekanisme pengesahan)

Apa yang boleh berlaku

Pertimbangkan potensi risiko JWT yang disimpan dalam kuki yang dihantar dengan setiap permintaan. Pengguna secara tidak sengaja boleh mencetuskan permintaan yang menghantar JWT ke pelayan berniat jahat, dan...

• Skrip Merentas Tapak (XSS).
• Serangan Penafian Perkhidmatan (DoS).
• Penyingkiran data. Tanpa perlindungan yang sewajarnya, ancaman ini boleh menjejaskan integriti dan prestasi aplikasi anda.

Kaedah

Evil Evil

Paling ringkas, namun paling berisiko.

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

Apabila anda menjalankan kod ini, ia log mesej itu. Pada asasnya, eval ialah jurubahasa JS yang mampu mengakses skop global/tetingkap.

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

Kod ini menggunakan pengambilan yang ditakrifkan dalam skop global. Jurubahasa tidak tahu mengenainya, tetapi kerana eval boleh mengakses tetingkap, ia tahu. Ini menunjukkan bahawa menjalankan eval dalam penyemak imbas adalah berbeza daripada menjalankannya dalam persekitaran pelayan atau pekerja.

eval(`document.body`);

Bagaimana dengan ini...

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

Kod ini akan menghentikan tab penyemak imbas. Anda mungkin bertanya mengapa pengguna akan melakukan ini kepada diri mereka sendiri. Nah, mereka mungkin menyalin kod dari Internet. Itulah sebabnya lebih disukai untuk melakukan analisis statik dengan/atau kotak masa pelaksanaan.

Anda mungkin mahu menyemak Dokumen MDN tentang eval

Pelaksanaan kotak masa boleh dilakukan dengan menjalankan kod dalam pekerja web dan menggunakan setTimeout untuk mengehadkan masa pelaksanaan.

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

Pembina Fungsi

Ini serupa dengan eval tetapi ia lebih selamat kerana ia tidak boleh mengakses skop yang disertakan.

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

Kod ini akan log 2.

Nota: Argumen kedua ialah badan fungsi.

Pembina fungsi tidak boleh mengakses skop yang disertakan supaya kod berikut akan menimbulkan ralat.

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

Tetapi ia boleh mengakses skop global supaya contoh pengambilan dari atas berfungsi.

WebWorker

Anda boleh menjalankan “Function Constructor dan eval pada WebWorker, yang sedikit lebih selamat disebabkan fakta bahawa tiada akses DOM.

Untuk meletakkan lebih banyak sekatan, pertimbangkan untuk tidak membenarkan menggunakan objek global seperti fetch, XMLHttpRequest, sendBeacon Semak tulisan ini tentang cara anda boleh melakukannya.

Terpencil-VM

Isolated-VM ialah perpustakaan yang membolehkan anda menjalankan kod dalam VM yang berasingan (antara muka Isolate v8)

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

Kod ini akan log hello world

WebAssembly

Ini adalah pilihan yang menarik kerana ia menyediakan persekitaran kotak pasir untuk menjalankan kod. Satu kaveat ialah anda memerlukan persekitaran dengan pengikatan Javascript. Walau bagaimanapun, projek menarik yang dipanggil Extism memudahkannya. Anda mungkin mahu mengikuti tutorial mereka.

Apa yang menarik mengenainya ialah anda akan menggunakan eval untuk menjalankan kod, tetapi memandangkan sifat WebAssembly, DOM, rangkaian, sistem fail dan akses kepada persekitaran hos tidak mungkin (walaupun ia mungkin berbeza berdasarkan masa larian 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

Atas ialah kandungan terperinci Menjalankan Kod JavaScript Tidak Dipercayai. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!