@secure-exec/core 0.1.0-rc.2 → 0.1.0-rc.3

package/dist/isolate-runtime/require-setup.js

@@ -270,6 +270,7 @@
     });
     return stub;
   }
+  var __internalModuleCache = _moduleCache;
   var __require = function require2(moduleName2) {
     return _requireFrom(moduleName2, _currentModule.dirname);
   };
@@ -286,7 +287,6 @@
   globalThis.require.resolve = function resolve(moduleName2) {
     return _resolveFrom(moduleName2, _currentModule.dirname);
   };
-  globalThis.require.cache = _moduleCache;
   function _debugRequire(phase, moduleName2, extra) {
     if (globalThis.__sandboxRequireDebug !== true) {
       return;
@@ -306,26 +306,26 @@
     let cacheKey = name;
     let resolved = null;
     const isRelative = name.startsWith("./") || name.startsWith("../");
-    if (!isRelative && _moduleCache[name]) {
+    if (!isRelative && __internalModuleCache[name]) {
       _debugRequire("cache-hit", name, name);
-      return _moduleCache[name];
+      return __internalModuleCache[name];
     }
     if (name === "fs") {
-      if (_moduleCache["fs"]) return _moduleCache["fs"];
+      if (__internalModuleCache["fs"]) return __internalModuleCache["fs"];
       const fsModule = globalThis.bridge?.fs || globalThis.bridge?.default || globalThis._fsModule || {};
-      _moduleCache["fs"] = fsModule;
+      __internalModuleCache["fs"] = fsModule;
       _debugRequire("loaded", name, "fs-special");
       return fsModule;
     }
     if (name === "fs/promises") {
-      if (_moduleCache["fs/promises"]) return _moduleCache["fs/promises"];
+      if (__internalModuleCache["fs/promises"]) return __internalModuleCache["fs/promises"];
       const fsModule = _requireFrom("fs", fromDir);
-      _moduleCache["fs/promises"] = fsModule.promises;
+      __internalModuleCache["fs/promises"] = fsModule.promises;
       _debugRequire("loaded", name, "fs-promises-special");
       return fsModule.promises;
     }
     if (name === "stream/promises") {
-      if (_moduleCache["stream/promises"]) return _moduleCache["stream/promises"];
+      if (__internalModuleCache["stream/promises"]) return __internalModuleCache["stream/promises"];
       const streamModule = _requireFrom("stream", fromDir);
       const promisesModule = {
         finished(stream, options) {
@@ -371,49 +371,49 @@
           });
         }
       };
-      _moduleCache["stream/promises"] = promisesModule;
+      __internalModuleCache["stream/promises"] = promisesModule;
       _debugRequire("loaded", name, "stream-promises-special");
       return promisesModule;
     }
     if (name === "child_process") {
-      if (_moduleCache["child_process"]) return _moduleCache["child_process"];
-      _moduleCache["child_process"] = _childProcessModule;
+      if (__internalModuleCache["child_process"]) return __internalModuleCache["child_process"];
+      __internalModuleCache["child_process"] = _childProcessModule;
       _debugRequire("loaded", name, "child-process-special");
       return _childProcessModule;
     }
     if (name === "http") {
-      if (_moduleCache["http"]) return _moduleCache["http"];
-      _moduleCache["http"] = _httpModule;
+      if (__internalModuleCache["http"]) return __internalModuleCache["http"];
+      __internalModuleCache["http"] = _httpModule;
       _debugRequire("loaded", name, "http-special");
       return _httpModule;
     }
     if (name === "https") {
-      if (_moduleCache["https"]) return _moduleCache["https"];
-      _moduleCache["https"] = _httpsModule;
+      if (__internalModuleCache["https"]) return __internalModuleCache["https"];
+      __internalModuleCache["https"] = _httpsModule;
       _debugRequire("loaded", name, "https-special");
       return _httpsModule;
     }
     if (name === "http2") {
-      if (_moduleCache["http2"]) return _moduleCache["http2"];
-      _moduleCache["http2"] = _http2Module;
+      if (__internalModuleCache["http2"]) return __internalModuleCache["http2"];
+      __internalModuleCache["http2"] = _http2Module;
       _debugRequire("loaded", name, "http2-special");
       return _http2Module;
     }
     if (name === "dns") {
-      if (_moduleCache["dns"]) return _moduleCache["dns"];
-      _moduleCache["dns"] = _dnsModule;
+      if (__internalModuleCache["dns"]) return __internalModuleCache["dns"];
+      __internalModuleCache["dns"] = _dnsModule;
       _debugRequire("loaded", name, "dns-special");
       return _dnsModule;
     }
     if (name === "os") {
-      if (_moduleCache["os"]) return _moduleCache["os"];
-      _moduleCache["os"] = _osModule;
+      if (__internalModuleCache["os"]) return __internalModuleCache["os"];
+      __internalModuleCache["os"] = _osModule;
       _debugRequire("loaded", name, "os-special");
       return _osModule;
     }
     if (name === "module") {
-      if (_moduleCache["module"]) return _moduleCache["module"];
-      _moduleCache["module"] = _moduleModule;
+      if (__internalModuleCache["module"]) return __internalModuleCache["module"];
+      __internalModuleCache["module"] = _moduleModule;
       _debugRequire("loaded", name, "module-special");
       return _moduleModule;
     }
@@ -422,7 +422,7 @@
       return globalThis.process;
     }
     if (name === "async_hooks") {
-      if (_moduleCache["async_hooks"]) return _moduleCache["async_hooks"];
+      if (__internalModuleCache["async_hooks"]) return __internalModuleCache["async_hooks"];
       class AsyncLocalStorage {
         constructor() {
           this._store = void 0;
@@ -491,7 +491,7 @@
           return null;
         }
       };
-      _moduleCache["async_hooks"] = asyncHooksModule;
+      __internalModuleCache["async_hooks"] = asyncHooksModule;
       _debugRequire("loaded", name, "async-hooks-special");
       return asyncHooksModule;
     }
@@ -508,7 +508,7 @@
         };
       };
       var _createChannel = _createChannel2;
-      if (_moduleCache[name]) return _moduleCache[name];
+      if (__internalModuleCache[name]) return __internalModuleCache[name];
       const dcModule = {
         channel: function() {
           return _createChannel2();
@@ -535,14 +535,14 @@
           };
         }
       };
-      _moduleCache[name] = dcModule;
+      __internalModuleCache[name] = dcModule;
       _debugRequire("loaded", name, "diagnostics-channel-special");
       return dcModule;
     }
     if (_deferredCoreModules.has(name)) {
-      if (_moduleCache[name]) return _moduleCache[name];
+      if (__internalModuleCache[name]) return __internalModuleCache[name];
       const deferredStub = _createDeferredModuleStub(name);
-      _moduleCache[name] = deferredStub;
+      __internalModuleCache[name] = deferredStub;
       _debugRequire("loaded", name, "deferred-stub");
       return deferredStub;
     }
@@ -551,7 +551,7 @@
     }
     const polyfillCode = _loadPolyfill.applySyncPromise(void 0, [name]);
     if (polyfillCode !== null) {
-      if (_moduleCache[name]) return _moduleCache[name];
+      if (__internalModuleCache[name]) return __internalModuleCache[name];
       const moduleObj = { exports: {} };
       _pendingModules[name] = moduleObj;
       let result = eval(polyfillCode);
@@ -561,16 +561,16 @@
       } else {
         moduleObj.exports = result;
       }
-      _moduleCache[name] = moduleObj.exports;
+      __internalModuleCache[name] = moduleObj.exports;
       delete _pendingModules[name];
       _debugRequire("loaded", name, "polyfill");
-      return _moduleCache[name];
+      return __internalModuleCache[name];
     }
     resolved = _resolveFrom(name, fromDir);
     cacheKey = resolved;
-    if (_moduleCache[cacheKey]) {
+    if (__internalModuleCache[cacheKey]) {
       _debugRequire("cache-hit", name, cacheKey);
-      return _moduleCache[cacheKey];
+      return __internalModuleCache[cacheKey];
     }
     if (_pendingModules[cacheKey]) {
       _debugRequire("pending-hit", name, cacheKey);
@@ -584,7 +584,7 @@
     }
     if (resolved.endsWith(".json")) {
       const parsed = JSON.parse(source);
-      _moduleCache[cacheKey] = parsed;
+      __internalModuleCache[cacheKey] = parsed;
       return parsed;
     }
     const normalizedSource = typeof source === "string" ? source.replace(/import\.meta\.url/g, "__filename").replace(/fileURLToPath\(__filename\)/g, "__filename").replace(/url\.fileURLToPath\(__filename\)/g, "__filename").replace(/fileURLToPath\.call\(void 0, __filename\)/g, "__filename") : source;
@@ -641,10 +641,46 @@
     } finally {
       _currentModule = prevModule;
     }
-    _moduleCache[cacheKey] = module.exports;
+    __internalModuleCache[cacheKey] = module.exports;
     delete _pendingModules[cacheKey];
     _debugRequire("loaded", name, cacheKey);
     return module.exports;
   }
   __requireExposeCustomGlobal("_requireFrom", _requireFrom);
+  var __moduleCacheProxy = new Proxy(__internalModuleCache, {
+    get(target, prop, receiver) {
+      return Reflect.get(target, prop, receiver);
+    },
+    set(_target, prop) {
+      throw new TypeError("Cannot set require.cache['" + String(prop) + "']");
+    },
+    deleteProperty(_target, prop) {
+      throw new TypeError("Cannot delete require.cache['" + String(prop) + "']");
+    },
+    defineProperty(_target, prop) {
+      throw new TypeError("Cannot define property '" + String(prop) + "' on require.cache");
+    },
+    has(target, prop) {
+      return Reflect.has(target, prop);
+    },
+    ownKeys(target) {
+      return Reflect.ownKeys(target);
+    },
+    getOwnPropertyDescriptor(target, prop) {
+      return Reflect.getOwnPropertyDescriptor(target, prop);
+    }
+  });
+  globalThis.require.cache = __moduleCacheProxy;
+  Object.defineProperty(globalThis, "_moduleCache", {
+    value: __moduleCacheProxy,
+    writable: false,
+    configurable: true,
+    enumerable: false
+  });
+  if (typeof _moduleModule !== "undefined") {
+    if (_moduleModule.Module) {
+      _moduleModule.Module._cache = __moduleCacheProxy;
+    }
+    _moduleModule._cache = __moduleCacheProxy;
+  }
 })();

package/dist/runtime-driver.d.ts

@@ -13,6 +13,8 @@ export interface ResourceBudgets {
     maxTimers?: number;
     /** Maximum child_process.spawn() invocations per execution. */
     maxChildProcesses?: number;
+    /** Maximum concurrent active handles (child processes, timers, servers) in the bridge handle map. */
+    maxHandles?: number;
 }
 export interface RuntimeDriverOptions {
     system: SystemDriver;

package/dist/shared/global-exposure.js

@@ -297,8 +297,8 @@ export const NODE_CUSTOM_GLOBAL_INVENTORY = [
     },
     {
         name: "_moduleCache",
-        classification: "mutable-runtime-state",
-        rationale: "Per-execution CommonJS/require cache state.",
+        classification: "hardened",
+        rationale: "Per-execution CommonJS/require cache — hardened via read-only Proxy to prevent cache poisoning.",
     },
     {
         name: "_pendingModules",
@@ -350,6 +350,31 @@ export const NODE_CUSTOM_GLOBAL_INVENTORY = [
         classification: "mutable-runtime-state",
         rationale: "Per-execution CommonJS file context state.",
     },
+    {
+        name: "fetch",
+        classification: "hardened",
+        rationale: "Network fetch API global — must not be replaceable by sandbox code.",
+    },
+    {
+        name: "Headers",
+        classification: "hardened",
+        rationale: "Network Headers API global — must not be replaceable by sandbox code.",
+    },
+    {
+        name: "Request",
+        classification: "hardened",
+        rationale: "Network Request API global — must not be replaceable by sandbox code.",
+    },
+    {
+        name: "Response",
+        classification: "hardened",
+        rationale: "Network Response API global — must not be replaceable by sandbox code.",
+    },
+    {
+        name: "Blob",
+        classification: "hardened",
+        rationale: "Blob API global stub — must not be replaceable by sandbox code.",
+    },
 ];
 export const HARDENED_NODE_CUSTOM_GLOBALS = NODE_CUSTOM_GLOBAL_INVENTORY
     .filter((entry) => entry.classification === "hardened")

package/dist/shared/permissions.js

@@ -6,6 +6,32 @@
  * for a category, guarded operations in that category are denied by default.
  */
 import { createEaccesError, createEnosysError } from "./errors.js";
+/** Normalize a filesystem path: collapse //, resolve . and .., strip trailing /. */
+function normalizeFsPath(path) {
+    // Collapse repeated slashes
+    let p = path.replace(/\/+/g, "/");
+    // Resolve . and .. segments
+    const parts = p.split("/");
+    const resolved = [];
+    for (const seg of parts) {
+        if (seg === ".")
+            continue;
+        if (seg === "..") {
+            // Don't pop past root
+            if (resolved.length > 1)
+                resolved.pop();
+        }
+        else {
+            resolved.push(seg);
+        }
+    }
+    p = resolved.join("/") || "/";
+    // Strip trailing slash (except root)
+    if (p.length > 1 && p.endsWith("/")) {
+        p = p.slice(0, -1);
+    }
+    return p;
+}
 /** Run the permission check; throw the deny error if no checker exists or it denies. */
 function checkPermission(check, request, onDenied) {
     if (!check) {
@@ -78,86 +104,90 @@ function fsOpToSyscall(op) {
  * Throws EACCES if the permission callback denies or is absent.
  */
 export function wrapFileSystem(fs, permissions) {
+    /** Check fs permission with normalized path to prevent traversal bypasses. */
+    function checkFs(op, path, reason) {
+        checkPermission(permissions?.fs, { op, path: normalizeFsPath(path) }, (req, r) => createEaccesError(fsOpToSyscall(req.op), req.path, r));
+    }
     return {
         readFile: async (path) => {
-            checkPermission(permissions?.fs, { op: "read", path }, (req, reason) => createEaccesError(fsOpToSyscall(req.op), req.path, reason));
+            checkFs("read", path);
             return fs.readFile(path);
         },
         readTextFile: async (path) => {
-            checkPermission(permissions?.fs, { op: "read", path }, (req, reason) => createEaccesError(fsOpToSyscall(req.op), req.path, reason));
+            checkFs("read", path);
             return fs.readTextFile(path);
         },
         readDir: async (path) => {
-            checkPermission(permissions?.fs, { op: "readdir", path }, (req, reason) => createEaccesError(fsOpToSyscall(req.op), req.path, reason));
+            checkFs("readdir", path);
             return fs.readDir(path);
         },
         readDirWithTypes: async (path) => {
-            checkPermission(permissions?.fs, { op: "readdir", path }, (req, reason) => createEaccesError(fsOpToSyscall(req.op), req.path, reason));
+            checkFs("readdir", path);
             return fs.readDirWithTypes(path);
         },
         writeFile: async (path, content) => {
-            checkPermission(permissions?.fs, { op: "write", path }, (req, reason) => createEaccesError(fsOpToSyscall(req.op), req.path, reason));
+            checkFs("write", path);
             return fs.writeFile(path, content);
         },
         createDir: async (path) => {
-            checkPermission(permissions?.fs, { op: "createDir", path }, (req, reason) => createEaccesError(fsOpToSyscall(req.op), req.path, reason));
+            checkFs("createDir", path);
             return fs.createDir(path);
         },
         mkdir: async (path) => {
-            checkPermission(permissions?.fs, { op: "mkdir", path }, (req, reason) => createEaccesError(fsOpToSyscall(req.op), req.path, reason));
+            checkFs("mkdir", path);
             return fs.mkdir(path);
         },
         exists: async (path) => {
-            checkPermission(permissions?.fs, { op: "exists", path }, (req, reason) => createEaccesError(fsOpToSyscall(req.op), req.path, reason));
+            checkFs("exists", path);
             return fs.exists(path);
         },
         stat: async (path) => {
-            checkPermission(permissions?.fs, { op: "stat", path }, (req, reason) => createEaccesError(fsOpToSyscall(req.op), req.path, reason));
+            checkFs("stat", path);
             return fs.stat(path);
         },
         removeFile: async (path) => {
-            checkPermission(permissions?.fs, { op: "rm", path }, (req, reason) => createEaccesError(fsOpToSyscall(req.op), req.path, reason));
+            checkFs("rm", path);
             return fs.removeFile(path);
         },
         removeDir: async (path) => {
-            checkPermission(permissions?.fs, { op: "rm", path }, (req, reason) => createEaccesError(fsOpToSyscall(req.op), req.path, reason));
+            checkFs("rm", path);
             return fs.removeDir(path);
         },
         rename: async (oldPath, newPath) => {
-            checkPermission(permissions?.fs, { op: "rename", path: oldPath }, (req, reason) => createEaccesError(fsOpToSyscall(req.op), req.path, reason));
-            checkPermission(permissions?.fs, { op: "rename", path: newPath }, (req, reason) => createEaccesError(fsOpToSyscall(req.op), req.path, reason));
+            checkFs("rename", oldPath);
+            checkFs("rename", newPath);
             return fs.rename(oldPath, newPath);
         },
         symlink: async (target, linkPath) => {
-            checkPermission(permissions?.fs, { op: "symlink", path: linkPath }, (req, reason) => createEaccesError(fsOpToSyscall(req.op), req.path, reason));
+            checkFs("symlink", linkPath);
             return fs.symlink(target, linkPath);
         },
         readlink: async (path) => {
-            checkPermission(permissions?.fs, { op: "readlink", path }, (req, reason) => createEaccesError(fsOpToSyscall(req.op), req.path, reason));
+            checkFs("readlink", path);
             return fs.readlink(path);
         },
         lstat: async (path) => {
-            checkPermission(permissions?.fs, { op: "stat", path }, (req, reason) => createEaccesError(fsOpToSyscall(req.op), req.path, reason));
+            checkFs("stat", path);
             return fs.lstat(path);
         },
         link: async (oldPath, newPath) => {
-            checkPermission(permissions?.fs, { op: "link", path: newPath }, (req, reason) => createEaccesError(fsOpToSyscall(req.op), req.path, reason));
+            checkFs("link", newPath);
             return fs.link(oldPath, newPath);
         },
         chmod: async (path, mode) => {
-            checkPermission(permissions?.fs, { op: "chmod", path }, (req, reason) => createEaccesError(fsOpToSyscall(req.op), req.path, reason));
+            checkFs("chmod", path);
             return fs.chmod(path, mode);
         },
         chown: async (path, uid, gid) => {
-            checkPermission(permissions?.fs, { op: "chown", path }, (req, reason) => createEaccesError(fsOpToSyscall(req.op), req.path, reason));
+            checkFs("chown", path);
             return fs.chown(path, uid, gid);
         },
         utimes: async (path, atime, mtime) => {
-            checkPermission(permissions?.fs, { op: "utimes", path }, (req, reason) => createEaccesError(fsOpToSyscall(req.op), req.path, reason));
+            checkFs("utimes", path);
             return fs.utimes(path, atime, mtime);
         },
         truncate: async (path, length) => {
-            checkPermission(permissions?.fs, { op: "truncate", path }, (req, reason) => createEaccesError(fsOpToSyscall(req.op), req.path, reason));
+            checkFs("truncate", path);
             return fs.truncate(path, length);
         },
     };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@secure-exec/core",
-  "version": "0.1.0-rc.2",
+  "version": "0.1.0-rc.3",
   "type": "module",
   "license": "Apache-2.0",
   "main": "./dist/index.js",