mirror of
https://github.com/komari-monitor/komari.git
synced 2026-11-22 16:00:46 +00:00
881 lines
29 KiB
Go
881 lines
29 KiB
Go
package jsruntime
|
|
|
|
import (
|
|
"bytes"
|
|
"io"
|
|
"net/http"
|
|
"net/http/httptest"
|
|
"os"
|
|
"path/filepath"
|
|
"runtime"
|
|
"strings"
|
|
"sync/atomic"
|
|
"testing"
|
|
"time"
|
|
)
|
|
|
|
func TestNodeCoreModulesAndECMAScriptBuiltins(t *testing.T) {
|
|
baseDir := t.TempDir()
|
|
runtime, err := New(`
|
|
async function verify() {
|
|
const fs = require("node:fs");
|
|
const path = require("path");
|
|
const os = require("os");
|
|
const EventEmitter = require("events");
|
|
fs.mkdirSync("data", { recursive: true });
|
|
fs.writeFileSync(path.join("data", "sync.txt"), "sync", "utf8");
|
|
await fs.promises.writeFile("data/async.txt", Buffer.from("async"));
|
|
const asyncText = await fs.promises.readFile("data/async.txt", "utf8");
|
|
const callbackText = await new Promise((resolve, reject) => fs.readFile("data/sync.txt", "utf8", (error, value) => error ? reject(error) : resolve(value)));
|
|
const entries = fs.readdirSync("data", { withFileTypes: true });
|
|
const stat = fs.statSync("data/sync.txt");
|
|
const emitter = new EventEmitter();
|
|
let eventValue = 0;
|
|
emitter.once("value", (value) => eventValue = value);
|
|
emitter.emit("value", 7);
|
|
const mapped = [1, 2, 3, 4].map((value) => value * 2).filter((value) => value > 4).reduce((sum, value) => sum + value, 0);
|
|
return asyncText === "async" && callbackText === "sync" && stat.isFile() && stat.size === 4 &&
|
|
entries.some((entry) => entry.name === "sync.txt" && entry.isFile()) &&
|
|
path.basename(path.join("a", "b.txt")) === "b.txt" && typeof os.platform() === "string" &&
|
|
process === require("process") && process.cwd() === __dirname && typeof process.nextTick === "function" &&
|
|
eventValue === 7 && mapped === 14 && JSON.parse(JSON.stringify({ ok: true })).ok && eval("2 + 3") === 5;
|
|
}
|
|
`, Options{NodeJS: true, BaseDir: baseDir, Console: io.Discard, Timeout: 3 * time.Second})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer runtime.Close()
|
|
|
|
if err := runtime.Call("verify"); err != nil {
|
|
t.Fatalf("Node core modules failed: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestNodeFileAccessConfinementAndAllowAll(t *testing.T) {
|
|
root := t.TempDir()
|
|
baseDir := filepath.Join(root, "base")
|
|
if err := os.Mkdir(baseDir, 0o700); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
outside := filepath.Join(root, "outside.txt")
|
|
if err := os.WriteFile(outside, []byte("outside"), 0o600); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := os.WriteFile(filepath.Join(root, "outside.js"), []byte(`module.exports = "outside module";`), 0o600); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
confined, err := New(`
|
|
function verify() {
|
|
let fsDenied = false;
|
|
let requireDenied = false;
|
|
try { require("fs").readFileSync("../outside.txt", "utf8"); }
|
|
catch (error) { fsDenied = String(error).includes("escapes BaseDir"); }
|
|
try { require("../outside.js"); }
|
|
catch (error) { requireDenied = String(error).includes("escapes BaseDir"); }
|
|
return fsDenied && requireDenied;
|
|
}
|
|
`, Options{NodeJS: true, BaseDir: baseDir, Console: io.Discard, Timeout: time.Second})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := confined.Call("verify"); err != nil {
|
|
confined.Close()
|
|
t.Fatalf("confined fs access failed: %v", err)
|
|
}
|
|
confined.Close()
|
|
|
|
unrestricted, err := New(`
|
|
function verify() {
|
|
return require("fs").readFileSync("../outside.txt", "utf8") === "outside" &&
|
|
require("../outside.js") === "outside module";
|
|
}
|
|
`, Options{NodeJS: true, BaseDir: baseDir, AllowAllFileAccess: true, Console: io.Discard, Timeout: time.Second})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer unrestricted.Close()
|
|
if err := unrestricted.Call("verify"); err != nil {
|
|
t.Fatalf("AllowAllFileAccess failed: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestNodeRequireUsesCurrentDirectoryAsImplicitBaseDir(t *testing.T) {
|
|
root := t.TempDir()
|
|
baseDir := filepath.Join(root, "base")
|
|
if err := os.Mkdir(baseDir, 0o700); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := os.WriteFile(filepath.Join(root, "outside.js"), []byte(`module.exports = true;`), 0o600); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
t.Chdir(baseDir)
|
|
|
|
runtime, err := New(`
|
|
function verify() {
|
|
try { require("../outside.js"); return false; }
|
|
catch (error) { return String(error).includes("escapes BaseDir"); }
|
|
}
|
|
`, Options{NodeJS: true, Console: io.Discard, Timeout: time.Second})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer runtime.Close()
|
|
if err := runtime.Call("verify"); err != nil {
|
|
t.Fatalf("implicit Node.js BaseDir confinement failed: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestProcessExitZeroIsNormalTermination(t *testing.T) {
|
|
baseDir := t.TempDir()
|
|
newRuntime := func(script string) *Runtime {
|
|
t.Helper()
|
|
runtime, err := New(script, Options{NodeJS: true, BaseDir: baseDir, Console: io.Discard, Timeout: time.Second})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
t.Cleanup(runtime.Close)
|
|
return runtime
|
|
}
|
|
|
|
if err := newRuntime(`
|
|
function sendMessage() { process.exit(0); }
|
|
`).Call("sendMessage"); err != nil {
|
|
t.Fatalf("process.exit(0) should be a normal termination: %v", err)
|
|
}
|
|
if err := newRuntime(`
|
|
async function sendMessage() { process.exit(0); }
|
|
`).Call("sendMessage"); err != nil {
|
|
t.Fatalf("async process.exit(0) should be a normal termination: %v", err)
|
|
}
|
|
|
|
failure, err := New(`
|
|
function sendMessage() { process.exit(3); }
|
|
`, Options{NodeJS: true, BaseDir: baseDir, Console: io.Discard, Timeout: time.Second})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer failure.Close()
|
|
if err := failure.Call("sendMessage"); err == nil || !strings.Contains(err.Error(), "exited with code 3") {
|
|
t.Fatalf("process.exit(3) should fail with the exit code, got: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestAsyncProcessExitZeroIsNotReportedAsFailure(t *testing.T) {
|
|
var output bytes.Buffer
|
|
runtime, err := New(`
|
|
function sendMessage() {
|
|
setTimeout(() => process.exit(0), 0);
|
|
return true;
|
|
}
|
|
`, Options{NodeJS: true, BaseDir: t.TempDir(), Console: &output, Timeout: time.Second})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer runtime.Close()
|
|
if err := runtime.Call("sendMessage"); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
time.Sleep(80 * time.Millisecond)
|
|
if strings.Contains(output.String(), "callback failed") {
|
|
t.Fatalf("process.exit(0) in a timer was reported as a failure: %s", output.String())
|
|
}
|
|
}
|
|
|
|
func TestHTTPClientRequestErrorWithoutListenerStillCloses(t *testing.T) {
|
|
server := httptest.NewServer(http.HandlerFunc(func(http.ResponseWriter, *http.Request) {}))
|
|
url := server.URL
|
|
server.Close()
|
|
|
|
var output bytes.Buffer
|
|
runtime, err := New(`
|
|
function sendMessage(url) {
|
|
return new Promise((resolve) => {
|
|
const request = require("http").get(url);
|
|
request.on("close", () => resolve(true));
|
|
});
|
|
}
|
|
`, Options{NodeJS: true, BaseDir: t.TempDir(), Console: &output, Timeout: 3 * time.Second})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer runtime.Close()
|
|
if err := runtime.Call("sendMessage", url); err != nil {
|
|
t.Fatalf("request close did not fire after connection failure: %v", err)
|
|
}
|
|
time.Sleep(80 * time.Millisecond)
|
|
if !strings.Contains(output.String(), "setTimeout callback failed") {
|
|
t.Fatalf("unhandled request error was not surfaced: %s", output.String())
|
|
}
|
|
}
|
|
|
|
func TestNodeFSSymlinkOperationsDoNotFollowFinalLink(t *testing.T) {
|
|
baseDir := t.TempDir()
|
|
target := filepath.Join(baseDir, "target.txt")
|
|
link := filepath.Join(baseDir, "link.txt")
|
|
if err := os.WriteFile(target, []byte("keep"), 0o600); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := os.Symlink(target, link); err != nil {
|
|
t.Skipf("symlinks are unavailable: %v", err)
|
|
}
|
|
targetDir := filepath.Join(baseDir, "target-dir")
|
|
linkDir := filepath.Join(baseDir, "link-dir")
|
|
if err := os.Mkdir(targetDir, 0o700); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := os.WriteFile(filepath.Join(targetDir, "keep.txt"), []byte("keep"), 0o600); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := os.Symlink(targetDir, linkDir); err != nil {
|
|
t.Skipf("directory symlinks are unavailable: %v", err)
|
|
}
|
|
|
|
runtime, err := New(`
|
|
async function verify() {
|
|
const fs = require("fs");
|
|
const stat = fs.lstatSync("link.txt");
|
|
const destination = fs.readlinkSync("link.txt");
|
|
await fs.promises.unlink("link.txt");
|
|
await fs.promises.rm("link-dir", { recursive: true });
|
|
return stat.isSymbolicLink() && destination.length > 0 && !fs.existsSync("link.txt") && !fs.existsSync("link-dir") &&
|
|
fs.readFileSync("target.txt", "utf8") === "keep" && fs.readFileSync("target-dir/keep.txt", "utf8") === "keep";
|
|
}
|
|
`, Options{NodeJS: true, BaseDir: baseDir, Console: io.Discard, Timeout: 3 * time.Second})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer runtime.Close()
|
|
if err := runtime.Call("verify"); err != nil {
|
|
t.Fatalf("symlink operation followed final link: %v", err)
|
|
}
|
|
if content, err := os.ReadFile(target); err != nil || string(content) != "keep" {
|
|
t.Fatalf("symlink target changed: content=%q err=%v", content, err)
|
|
}
|
|
if content, err := os.ReadFile(filepath.Join(targetDir, "keep.txt")); err != nil || string(content) != "keep" {
|
|
t.Fatalf("directory symlink target changed: content=%q err=%v", content, err)
|
|
}
|
|
}
|
|
|
|
func TestNodeFSClosedRootNeverFallsBackToHostPath(t *testing.T) {
|
|
root := t.TempDir()
|
|
baseDir := filepath.Join(root, "base")
|
|
outside := filepath.Join(root, "outside")
|
|
if err := os.MkdirAll(filepath.Join(baseDir, "parent"), 0o700); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := os.Mkdir(outside, 0o700); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
|
|
jsRuntime, err := New(`function verify() { return true; }`, Options{
|
|
NodeJS: true, BaseDir: baseDir, Console: io.Discard,
|
|
})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer jsRuntime.Close()
|
|
|
|
resolved, err := jsRuntime.resolveNodePath(filepath.Join("parent", "escaped.txt"), true)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
jsRuntime.fsModule.Close()
|
|
if err := os.Rename(filepath.Join(baseDir, "parent"), filepath.Join(baseDir, "original-parent")); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := os.Symlink(outside, filepath.Join(baseDir, "parent")); err != nil {
|
|
t.Skipf("symlinks are unavailable: %v", err)
|
|
}
|
|
|
|
if err := jsRuntime.nodeWriteFile(resolved, []byte("escape"), 0o600); err == nil {
|
|
t.Fatal("closed filesystem accepted a path operation")
|
|
}
|
|
if _, err := os.Stat(filepath.Join(outside, "escaped.txt")); !os.IsNotExist(err) {
|
|
t.Fatalf("closed filesystem fell back outside BaseDir: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestNodeFSAccessModeIsValidated(t *testing.T) {
|
|
jsRuntime, err := New(`
|
|
async function verify() {
|
|
const fs = require("fs");
|
|
fs.writeFileSync("access.txt", "ok");
|
|
let syncInvalid = false;
|
|
try { fs.accessSync("access.txt", 8); }
|
|
catch (error) { syncInvalid = error.code === "EINVAL"; }
|
|
const asyncInvalid = await new Promise((resolve) => fs.access("access.txt", 8, (error) => resolve(error && error.code === "EINVAL")));
|
|
const exists = await new Promise((resolve) => fs.access("access.txt", fs.constants.F_OK, (error) => resolve(!error)));
|
|
return syncInvalid && asyncInvalid && exists;
|
|
}
|
|
`, Options{NodeJS: true, BaseDir: t.TempDir(), Console: io.Discard, Timeout: 3 * time.Second})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer jsRuntime.Close()
|
|
if err := jsRuntime.Call("verify"); err != nil {
|
|
t.Fatalf("fs.access mode validation failed: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestNodeFSCallbackAndPromiseShapes(t *testing.T) {
|
|
runtime, err := New(`
|
|
async function verify() {
|
|
const fs = require("fs");
|
|
const handle = await fs.promises.open("shape.txt", "w+");
|
|
if (typeof handle.fd !== "number" || typeof handle.close !== "function") return false;
|
|
const written = await handle.write(Buffer.from("shape"), 0, 5, 0);
|
|
const target = Buffer.alloc(5);
|
|
const read = await handle.read(target, 0, 5, 0);
|
|
const callbackShape = await new Promise((resolve, reject) => {
|
|
const second = Buffer.alloc(5);
|
|
fs.read(handle.fd, second, 0, 5, 0, (error, bytesRead, buffer) => {
|
|
if (error) reject(error); else resolve(bytesRead === 5 && buffer === second && buffer.toString() === "shape");
|
|
});
|
|
});
|
|
await handle.close();
|
|
return written.bytesWritten === 5 && written.buffer.toString() === "shape" &&
|
|
read.bytesRead === 5 && read.buffer === target && target.toString() === "shape" && callbackShape;
|
|
}
|
|
`, Options{NodeJS: true, BaseDir: t.TempDir(), Console: io.Discard, Timeout: 3 * time.Second})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer runtime.Close()
|
|
if err := runtime.Call("verify"); err != nil {
|
|
t.Fatalf("fs callback or Promise shape failed: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestNodeFSAsyncIOLeavesEventLoopResponsive(t *testing.T) {
|
|
reader, writer, err := os.Pipe()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer writer.Close()
|
|
|
|
runtime, err := New(`
|
|
function verify(fd) {
|
|
const fs = require("fs");
|
|
fs.read(fd, Buffer.alloc(1), 0, 1, null, () => {});
|
|
return new Promise((resolve) => setTimeout(() => resolve(true), 20));
|
|
}
|
|
`, Options{NodeJS: true, BaseDir: t.TempDir(), Console: io.Discard, Timeout: 500 * time.Millisecond})
|
|
if err != nil {
|
|
reader.Close()
|
|
t.Fatal(err)
|
|
}
|
|
defer runtime.Close()
|
|
|
|
resourceID := runtime.addNodeResource(func() { _ = reader.Close() })
|
|
if resourceID == 0 {
|
|
t.Fatal("failed to register pipe")
|
|
}
|
|
runtime.fileMu.Lock()
|
|
runtime.fileID++
|
|
fd := runtime.fileID
|
|
runtime.files[fd] = nodeFileHandle{file: reader, resourceID: resourceID}
|
|
runtime.fileMu.Unlock()
|
|
|
|
if err := runtime.Call("verify", fd); err != nil {
|
|
t.Fatalf("fs.read blocked the event loop: %v", err)
|
|
}
|
|
_, _ = writer.Write([]byte{1})
|
|
}
|
|
|
|
func TestNodeResourceRegistrationAfterCloseClosesImmediately(t *testing.T) {
|
|
runtime, err := New(`function verify() { return true; }`, Options{NodeJS: true, BaseDir: t.TempDir(), Console: io.Discard})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
runtime.Close()
|
|
var closed atomic.Bool
|
|
if id := runtime.addNodeResource(func() { closed.Store(true) }); id != 0 {
|
|
t.Fatalf("closed Runtime accepted resource %d", id)
|
|
}
|
|
if !closed.Load() {
|
|
t.Fatal("late resource was not closed")
|
|
}
|
|
}
|
|
|
|
func TestNodeRootRejectsParentSymlinkSwap(t *testing.T) {
|
|
baseDir := t.TempDir()
|
|
parent := filepath.Join(baseDir, "parent")
|
|
outside := t.TempDir()
|
|
if err := os.Mkdir(parent, 0o700); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
jsRuntime, err := New(`function verify() { return true; }`, Options{NodeJS: true, BaseDir: baseDir, Console: io.Discard})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer jsRuntime.Close()
|
|
resolved, err := jsRuntime.resolveNodePath(filepath.Join("parent", "escaped.txt"), true)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := os.Rename(parent, filepath.Join(baseDir, "original-parent")); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := os.Symlink(outside, parent); err != nil {
|
|
t.Skipf("symlinks are unavailable: %v", err)
|
|
}
|
|
if err := jsRuntime.nodeWriteFile(resolved, []byte("escape"), 0o600); err == nil {
|
|
t.Fatal("rooted write followed a swapped parent symlink")
|
|
}
|
|
if _, err := os.Stat(filepath.Join(outside, "escaped.txt")); !os.IsNotExist(err) {
|
|
t.Fatalf("write escaped BaseDir: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestNodeFSErrorsExposeNodeFields(t *testing.T) {
|
|
jsRuntime, err := New(`
|
|
async function verify() {
|
|
try {
|
|
await require("fs").promises.readFile("missing.txt");
|
|
return false;
|
|
} catch (error) {
|
|
return error.name === "Error" && error.code === "ENOENT" &&
|
|
typeof error.errno === "number" && error.errno < 0 && typeof error.syscall === "string" &&
|
|
typeof error.path === "string";
|
|
}
|
|
}
|
|
`, Options{NodeJS: true, BaseDir: t.TempDir(), Console: io.Discard})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer jsRuntime.Close()
|
|
if err := jsRuntime.Call("verify"); err != nil {
|
|
t.Fatalf("fs error shape is not Node-compatible: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestNodePathCrossPlatformSemantics(t *testing.T) {
|
|
runtime, err := New(`
|
|
function verify() {
|
|
const path = require("path");
|
|
return path.extname("a.") === "." && path.extname("a..") === "." && path.extname(".hidden") === "" &&
|
|
path.posix.basename("/") === "" && path.posix.parse("/").base === "" && path.posix.parse("foo").dir === "" &&
|
|
path.posix.normalize("a\\b") === "a\\b" && path.posix.normalize("foo/bar//") === "foo/bar/" &&
|
|
path.posix.join("foo", "bar/") === "foo/bar/" &&
|
|
path.posix.relative("/", "/a") === "a" && path.posix.relative("/a", "/") === ".." &&
|
|
path.posix.resolve("a").endsWith("/a") &&
|
|
path.win32.normalize("C:/foo/../bar/a.") === "C:\\bar\\a." &&
|
|
path.win32.basename("C:foo") === "foo" && path.win32.parse("C:foo").base === "foo" &&
|
|
path.win32.parse("\\\\server\\share\\").root === "\\\\server\\share\\" &&
|
|
path.win32.resolve("C:\\base", "C:foo") === "C:\\base\\foo" &&
|
|
path.win32.resolve("C:\\base", "\\foo") === "C:\\foo" &&
|
|
path.win32.join("C:\\a", "b") === "C:\\a\\b" && path.win32.isAbsolute("C:\\a") &&
|
|
path.win32.resolve("C:\\a") === "C:\\a" &&
|
|
path.win32.relative("C:\\a\\b", "C:\\a\\c") === "..\\c" &&
|
|
path.win32.format({ dir: "C:\\a", name: "b", ext: "txt" }) === "C:\\a\\b.txt" &&
|
|
path.win32.toNamespacedPath("C:\\a") === "\\\\?\\C:\\a";
|
|
}
|
|
`, Options{NodeJS: true, BaseDir: t.TempDir(), Console: io.Discard})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer runtime.Close()
|
|
if err := runtime.Call("verify"); err != nil {
|
|
t.Fatalf("path compatibility failed: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestProcessNextTickPrecedesPromiseMicrotasks(t *testing.T) {
|
|
jsRuntime, err := New(`
|
|
function verify() {
|
|
const order = [];
|
|
Promise.resolve().then(() => {
|
|
order.push("promise-1");
|
|
process.nextTick(() => order.push("tick-2"));
|
|
});
|
|
Promise.resolve().then(() => order.push("promise-2"));
|
|
process.nextTick(() => order.push("tick-1"));
|
|
return new Promise((resolve) => setImmediate(() => resolve(order.join(",") === "tick-1,promise-1,promise-2,tick-2")));
|
|
}
|
|
`, Options{NodeJS: true, BaseDir: t.TempDir(), Console: io.Discard})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer jsRuntime.Close()
|
|
if err := jsRuntime.Call("verify"); err != nil {
|
|
t.Fatalf("process.nextTick ordering failed: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestProcessNextTickPrecedesPromisesInAsyncHostCallback(t *testing.T) {
|
|
jsRuntime, err := New(`
|
|
function verify() {
|
|
return new Promise((resolve) => {
|
|
require("fs").exists("missing.txt", () => {
|
|
const order = [];
|
|
Promise.resolve().then(() => order.push("promise"));
|
|
process.nextTick(() => order.push("tick"));
|
|
setImmediate(() => resolve(order.join(",") === "tick,promise"));
|
|
});
|
|
});
|
|
}
|
|
`, Options{NodeJS: true, BaseDir: t.TempDir(), Console: io.Discard})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer jsRuntime.Close()
|
|
if err := jsRuntime.Call("verify"); err != nil {
|
|
t.Fatalf("process.nextTick ordering in an async host callback failed: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestFetchResponseBodyLimit(t *testing.T) {
|
|
server := httptest.NewServer(http.HandlerFunc(func(response http.ResponseWriter, _ *http.Request) {
|
|
_, _ = response.Write([]byte("response-too-large"))
|
|
}))
|
|
defer server.Close()
|
|
|
|
jsRuntime, err := New(`
|
|
async function verify(url) {
|
|
try {
|
|
await fetch(url);
|
|
return false;
|
|
} catch (error) {
|
|
return error.name === "TypeError" && String(error).includes("HTTP body exceeds 8 bytes");
|
|
}
|
|
}
|
|
`, Options{Console: io.Discard, Timeout: time.Second, MaxHTTPBodyBytes: 8})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer jsRuntime.Close()
|
|
if err := jsRuntime.Call("verify", server.URL); err != nil {
|
|
t.Fatalf("fetch response limit failed: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestNodeOSAndProcessMetrics(t *testing.T) {
|
|
runtime, err := New(`
|
|
function verify() {
|
|
const os = require("os");
|
|
const memory = process.memoryUsage();
|
|
const cpu = process.cpuUsage();
|
|
const resources = process.resourceUsage();
|
|
return os.totalmem() > 0 && os.freemem() > 0 && os.uptime() > 0 && os.cpus().length > 0 &&
|
|
typeof os.release() === "string" && os.release().length > 0 &&
|
|
typeof process.memoryUsage.rss === "function" && process.memoryUsage.rss() > 0 && memory.rss > 0 &&
|
|
cpu.user >= 0 && cpu.system >= 0 && resources.userCPUTime >= 0 && resources.systemCPUTime >= 0 && resources.maxRSS > 0;
|
|
}
|
|
`, Options{NodeJS: true, BaseDir: t.TempDir(), Console: io.Discard})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer runtime.Close()
|
|
if err := runtime.Call("verify"); err != nil {
|
|
t.Fatalf("os/process metrics failed: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestChildProcessPermissionAndExecution(t *testing.T) {
|
|
denied, err := New(`
|
|
function verify() {
|
|
try { require("child_process"); return false; }
|
|
catch (error) { return String(error).includes("AllowExec"); }
|
|
}
|
|
`, Options{NodeJS: true, BaseDir: t.TempDir(), Console: io.Discard, Timeout: time.Second})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := denied.Call("verify"); err != nil {
|
|
denied.Close()
|
|
t.Fatalf("child_process permission failed: %v", err)
|
|
}
|
|
denied.Close()
|
|
|
|
command := "printf child"
|
|
if runtime.GOOS == "windows" {
|
|
command = "echo child"
|
|
}
|
|
allowed, err := New(`
|
|
function verify(command) {
|
|
const childProcess = require("child_process");
|
|
const syncOutput = childProcess.execSync(command, { encoding: "utf8" }).trim();
|
|
return new Promise((resolve) => {
|
|
const child = childProcess.spawn(command, [], { shell: true, encoding: "utf8" });
|
|
let output = "";
|
|
child.stdout.on("data", (chunk) => output += String(chunk));
|
|
child.on("close", (code) => resolve(code === 0 && syncOutput === "child" && output.trim() === "child"));
|
|
child.on("error", () => resolve(false));
|
|
});
|
|
}
|
|
`, Options{NodeJS: true, AllowExec: true, BaseDir: t.TempDir(), Console: io.Discard, Timeout: 5 * time.Second})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer allowed.Close()
|
|
if err := allowed.Call("verify", command); err != nil {
|
|
t.Fatalf("child_process execution failed: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestChildProcessOutputLimitAndExitCode(t *testing.T) {
|
|
jsRuntime, err := New(`
|
|
function execFile(command, environment, maxBuffer) {
|
|
return new Promise((resolve) => {
|
|
require("child_process").execFile(
|
|
command,
|
|
["-test.run=^TestNodeChildProcessHelper$"],
|
|
{ env: environment, encoding: "utf8", maxBuffer },
|
|
(error, stdout) => resolve({ error, stdout })
|
|
);
|
|
});
|
|
}
|
|
async function verify(command, outputEnvironment, exitEnvironment) {
|
|
const limited = await execFile(command, outputEnvironment, 4096);
|
|
const commandLimited = await execFile(command, outputEnvironment, 64);
|
|
const exited = await execFile(command, exitEnvironment, 4096);
|
|
const valid = limited.error && limited.error.code === "ERR_CHILD_PROCESS_STDIO_MAXBUFFER" &&
|
|
String(limited.error).includes("stdout maxBuffer length exceeded") && limited.stdout.length === 128 &&
|
|
commandLimited.error && commandLimited.error.code === "ERR_CHILD_PROCESS_STDIO_MAXBUFFER" && commandLimited.stdout.length === 64 &&
|
|
exited.error && exited.error.code === 7;
|
|
if (!valid) {
|
|
throw new Error(JSON.stringify({
|
|
limitedError: String(limited.error), limitedCode: limited.error && limited.error.code,
|
|
limitedLength: limited.stdout && limited.stdout.length,
|
|
commandLimitedError: String(commandLimited.error), commandLimitedLength: commandLimited.stdout && commandLimited.stdout.length,
|
|
exitedError: String(exited.error), exitedCode: exited.error && exited.error.code
|
|
}));
|
|
}
|
|
return true;
|
|
}
|
|
`, Options{
|
|
NodeJS: true, AllowExec: true, BaseDir: t.TempDir(), Console: io.Discard,
|
|
Timeout: 3 * time.Second, MaxChildOutputBytes: 128,
|
|
})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer jsRuntime.Close()
|
|
if jsRuntime.maxChildOutputBytes != 128 {
|
|
t.Fatalf("MaxChildOutputBytes = %d, want 128", jsRuntime.maxChildOutputBytes)
|
|
}
|
|
if err := jsRuntime.Call(
|
|
"verify",
|
|
os.Args[0],
|
|
childHelperEnvironment("output"),
|
|
childHelperEnvironment("exit"),
|
|
); err != nil {
|
|
t.Fatalf("child_process output limit or exit code failed: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestChildProcessSyncTimeoutLeavesRuntimeUsable(t *testing.T) {
|
|
jsRuntime, err := New(`
|
|
function verify(command, environment) {
|
|
try {
|
|
require("child_process").execFileSync(
|
|
command,
|
|
["-test.run=^TestNodeChildProcessHelper$"],
|
|
{ env: environment, timeout: 40 }
|
|
);
|
|
return false;
|
|
} catch (_) {
|
|
return true;
|
|
}
|
|
}
|
|
function healthy() { return eval("6 * 7") === 42; }
|
|
`, Options{NodeJS: true, AllowExec: true, BaseDir: t.TempDir(), Console: io.Discard, Timeout: time.Second})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer jsRuntime.Close()
|
|
if err := jsRuntime.Call("verify", os.Args[0], childHelperEnvironment("sleep")); err != nil {
|
|
t.Fatalf("child_process sync timeout failed: %v", err)
|
|
}
|
|
if err := jsRuntime.Call("healthy"); err != nil {
|
|
t.Fatalf("runtime was unusable after child_process sync timeout: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestRuntimeCloseClearsNodeFileDescriptors(t *testing.T) {
|
|
jsRuntime, err := New(`
|
|
function verify() {
|
|
require("fs").openSync("held.txt", "w");
|
|
return true;
|
|
}
|
|
`, Options{NodeJS: true, BaseDir: t.TempDir(), Console: io.Discard})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := jsRuntime.Call("verify"); err != nil {
|
|
jsRuntime.Close()
|
|
t.Fatal(err)
|
|
}
|
|
jsRuntime.fileMu.Lock()
|
|
openBeforeClose := len(jsRuntime.files)
|
|
jsRuntime.fileMu.Unlock()
|
|
if openBeforeClose != 1 {
|
|
jsRuntime.Close()
|
|
t.Fatalf("expected one open descriptor, got %d", openBeforeClose)
|
|
}
|
|
jsRuntime.Close()
|
|
jsRuntime.fileMu.Lock()
|
|
openAfterClose := len(jsRuntime.files)
|
|
jsRuntime.fileMu.Unlock()
|
|
if openAfterClose != 0 {
|
|
t.Fatalf("Runtime.Close left %d descriptors registered", openAfterClose)
|
|
}
|
|
}
|
|
|
|
func TestNodeNetAndHTTPServers(t *testing.T) {
|
|
runtime, err := New(`
|
|
function verifyNet() {
|
|
const net = require("net");
|
|
return new Promise((resolve) => {
|
|
const server = net.createServer((socket) => socket.on("data", (data) => socket.end(data)));
|
|
server.listen(0, "127.0.0.1", () => {
|
|
const client = net.connect(server.address().port, "127.0.0.1");
|
|
let output = "";
|
|
client.setEncoding("utf8");
|
|
client.on("connect", () => client.write("echo"));
|
|
client.on("data", (data) => output += data);
|
|
client.on("end", () => server.close(() => resolve(output === "echo")));
|
|
client.on("error", () => resolve(false));
|
|
});
|
|
});
|
|
}
|
|
function verifyHTTP() {
|
|
const http = require("http");
|
|
return new Promise((resolve) => {
|
|
const server = http.createServer((request, response) => {
|
|
response.statusCode = 201;
|
|
response.setHeader("X-Node", "yes");
|
|
response.end("ready");
|
|
});
|
|
server.listen(0, "127.0.0.1", async () => {
|
|
const response = await fetch("http://127.0.0.1:" + server.address().port + "/test");
|
|
const text = await response.text();
|
|
server.close(() => resolve(response.status === 201 && response.headers.get("x-node") === "yes" && text === "ready"));
|
|
});
|
|
});
|
|
}
|
|
`, Options{NodeJS: true, AllowListen: true, BaseDir: t.TempDir(), Console: io.Discard, Timeout: 8 * time.Second})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer runtime.Close()
|
|
if err := runtime.Call("verifyNet"); err != nil {
|
|
t.Fatalf("Node net server failed: %v", err)
|
|
}
|
|
if err := runtime.Call("verifyHTTP"); err != nil {
|
|
t.Fatalf("Node HTTP server failed: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestNodeCloseCancelsPendingListen(t *testing.T) {
|
|
jsRuntime, err := New(`
|
|
function verify(moduleName) {
|
|
const api = require(moduleName);
|
|
return new Promise((resolve) => {
|
|
let listened = false;
|
|
const servers = [];
|
|
for (let index = 0; index < 32; index++) {
|
|
const server = api.createServer();
|
|
servers.push(server);
|
|
server.on("listening", () => { listened = true; });
|
|
server.listen(0, "127.0.0.1");
|
|
let duplicateRejected = false;
|
|
try { server.listen(0, "127.0.0.1"); }
|
|
catch (_) { duplicateRejected = true; }
|
|
if (!duplicateRejected) return resolve(false);
|
|
server.close();
|
|
}
|
|
setTimeout(() => resolve(!listened && servers.every((server) => server.address() === null)), 100);
|
|
});
|
|
}
|
|
function verifyReuse(moduleName) {
|
|
const api = require(moduleName);
|
|
return new Promise((resolve) => {
|
|
const server = api.createServer();
|
|
let staleCallbackCalls = 0;
|
|
server.listen(0, "127.0.0.1", () => { staleCallbackCalls++; });
|
|
server.close();
|
|
setTimeout(() => {
|
|
server.listen(0, "127.0.0.1", () => {
|
|
server.close(() => resolve(staleCallbackCalls === 0));
|
|
});
|
|
}, 20);
|
|
});
|
|
}
|
|
`, Options{NodeJS: true, AllowListen: true, BaseDir: t.TempDir(), Console: io.Discard, Timeout: 3 * time.Second})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer jsRuntime.Close()
|
|
for _, moduleName := range []string{"net", "http"} {
|
|
if err := jsRuntime.Call("verify", moduleName); err != nil {
|
|
t.Fatalf("%s pending listen was not cancelled: %v", moduleName, err)
|
|
}
|
|
if err := jsRuntime.Call("verifyReuse", moduleName); err != nil {
|
|
t.Fatalf("%s server retained a cancelled listen callback: %v", moduleName, err)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestNodeListenPermission(t *testing.T) {
|
|
runtime, err := New(`
|
|
function verify() {
|
|
try { require("net").createServer().listen(0); return false; }
|
|
catch (error) { return String(error).includes("AllowListen"); }
|
|
}
|
|
`, Options{NodeJS: true, BaseDir: t.TempDir(), Console: io.Discard, Timeout: time.Second})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer runtime.Close()
|
|
if err := runtime.Call("verify"); err != nil {
|
|
t.Fatalf("listen permission failed: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestEvalRemainsInterruptible(t *testing.T) {
|
|
runtime, err := New(`function verify() { eval("for (;;) {}"); return true; }`, Options{NodeJS: true, BaseDir: t.TempDir(), Console: io.Discard, Timeout: 40 * time.Millisecond})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer runtime.Close()
|
|
if err := runtime.Call("verify"); err == nil || !strings.Contains(err.Error(), "timeout") {
|
|
t.Fatalf("expected eval timeout, got %v", err)
|
|
}
|
|
}
|
|
|
|
const childHelperModeEnvironment = "KOMARI_JSRUNTIME_CHILD_HELPER_MODE"
|
|
|
|
func childHelperEnvironment(mode string) map[string]string {
|
|
environment := make(map[string]string)
|
|
for _, item := range os.Environ() {
|
|
name, value, found := strings.Cut(item, "=")
|
|
if found && name != "" {
|
|
environment[name] = value
|
|
}
|
|
}
|
|
environment[childHelperModeEnvironment] = mode
|
|
return environment
|
|
}
|
|
|
|
func TestNodeChildProcessHelper(t *testing.T) {
|
|
switch os.Getenv(childHelperModeEnvironment) {
|
|
case "":
|
|
return
|
|
case "output":
|
|
_, _ = io.WriteString(os.Stdout, strings.Repeat("x", 4096))
|
|
os.Exit(0)
|
|
case "exit":
|
|
os.Exit(7)
|
|
case "sleep":
|
|
time.Sleep(5 * time.Second)
|
|
os.Exit(0)
|
|
case "echo":
|
|
_, _ = io.Copy(os.Stdout, os.Stdin)
|
|
os.Exit(0)
|
|
default:
|
|
os.Exit(2)
|
|
}
|
|
}
|