just-bash 2.12.3 → 2.12.5

package/dist/bundle/chunks/worker.js

@@ -10,6 +10,19 @@ import { createRequire } from "node:module";
 import { dirname } from "node:path";
 import { parentPort, workerData } from "node:worker_threads";
 
+// src/fs/sanitize-error.ts
+function sanitizeErrorMessage(message) {
+  if (!message) return message;
+  let sanitized = message.replace(/\n\s+at\s.*/g, "");
+  sanitized = sanitized.replace(
+    /(?:\/(?:Users|home|private|var|opt|Library|System|usr|etc|tmp|nix|snap))\b[^\s'",)}\]:]*/g,
+    "<path>"
+  );
+  sanitized = sanitized.replace(/node:internal\/[^\s'",)}\]:]+/g, "<internal>");
+  sanitized = sanitized.replace(/[A-Z]:\\[^\s'",)}\]:]+/g, "<path>");
+  return sanitized;
+}
+
 // src/security/blocked-globals.ts
 function getBlockedGlobals() {
   const globals = [
@@ -177,7 +190,14 @@ function getBlockedGlobals() {
     // in defense-in-depth-box.ts and worker-defense-in-depth.ts
     // Note: process.connected is a boolean primitive, handled specially
     // in defense-in-depth-box.ts and worker-defense-in-depth.ts
-    // Working directory manipulation
+    // Working directory access/manipulation
+    {
+      prop: "cwd",
+      target: process,
+      violationType: "process_chdir",
+      strategy: "throw",
+      reason: "process.cwd could disclose real host working directory path"
+    },
     {
       prop: "chdir",
       target: process,
@@ -241,6 +261,13 @@ function getBlockedGlobals() {
       reason: "FinalizationRegistry could be used to leak references outside sandbox"
     },
     // Introspection/interception vectors (freeze instead of throw)
+    // SECURITY RATIONALE: Reflect is frozen (not blocked) because:
+    // 1. Defense infrastructure uses Reflect.apply/get/set/construct internally
+    // 2. Frozen Reflect cannot be mutated but remains fully functional
+    // 3. Reflect.construct(Function, ['code']) IS safe because globalThis.Function
+    //    is replaced with a blocking proxy — Reflect.construct receives the proxy
+    // 4. Security depends on NEVER leaking original Function/eval references.
+    //    If an unpatched Function ref leaked, Reflect.construct would bypass defense.
     {
       prop: "Reflect",
       target: globalThis,
@@ -697,6 +724,64 @@ var WorkerDefenseInDepth = class {
         } finally {
           self.inTrap = false;
         }
+      },
+      deleteProperty(target, prop) {
+        if (self.inTrap) {
+          return Reflect.deleteProperty(target, prop);
+        }
+        self.inTrap = true;
+        try {
+          const fullPath = `${path}.${String(prop)}`;
+          const message = `${fullPath} deletion is blocked in worker context`;
+          const violation = self.recordViolation(
+            violationType,
+            fullPath,
+            message
+          );
+          if (!auditMode) {
+            throw new WorkerSecurityViolationError(message, violation);
+          }
+          return Reflect.deleteProperty(target, prop);
+        } finally {
+          self.inTrap = false;
+        }
+      },
+      setPrototypeOf(target, proto) {
+        if (self.inTrap) {
+          return Reflect.setPrototypeOf(target, proto);
+        }
+        self.inTrap = true;
+        try {
+          const message = `${path} setPrototypeOf is blocked in worker context`;
+          const violation = self.recordViolation(violationType, path, message);
+          if (!auditMode) {
+            throw new WorkerSecurityViolationError(message, violation);
+          }
+          return Reflect.setPrototypeOf(target, proto);
+        } finally {
+          self.inTrap = false;
+        }
+      },
+      defineProperty(target, prop, descriptor) {
+        if (self.inTrap) {
+          return Reflect.defineProperty(target, prop, descriptor);
+        }
+        self.inTrap = true;
+        try {
+          const fullPath = `${path}.${String(prop)}`;
+          const message = `${fullPath} defineProperty is blocked in worker context`;
+          const violation = self.recordViolation(
+            violationType,
+            fullPath,
+            message
+          );
+          if (!auditMode) {
+            throw new WorkerSecurityViolationError(message, violation);
+          }
+          return Reflect.defineProperty(target, prop, descriptor);
+        } finally {
+          self.inTrap = false;
+        }
       }
     });
   }
@@ -1253,9 +1338,23 @@ var WorkerDefenseInDepth = class {
   }
 };
 
-// src/timers.ts
-var _setTimeout = globalThis.setTimeout;
-var _clearTimeout = globalThis.clearTimeout;
+// src/security/wasm-callback.ts
+function sanitizeUnknownError(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  return sanitizeErrorMessage(message);
+}
+function wrapWasmCallback(component, phase, callback) {
+  return (...args) => {
+    try {
+      return callback(...args);
+    } catch (error) {
+      const message = sanitizeUnknownError(error);
+      throw new Error(`${component} ${phase} callback failed: ${message}`);
+    }
+  };
+}
+
+// src/security/trusted-globals.ts
 var _SharedArrayBuffer = globalThis.SharedArrayBuffer;
 var _Atomics = globalThis.Atomics;
 var _performanceNow = performance.now.bind(performance);
@@ -2413,9 +2512,8 @@ function createHTTPFS(backend, FS) {
             });
             lastResponse = encoder.encode(JSON.stringify(result));
           } catch (e) {
-            lastResponse = encoder.encode(
-              JSON.stringify({ error: e.message })
-            );
+            const message = sanitizeErrorMessage(e.message);
+            lastResponse = encoder.encode(JSON.stringify({ error: message }));
           }
         }
         delete stream.hostContent;
@@ -2543,6 +2641,16 @@ sys.modules['jb_http'] = jb_http
 `;
 }
 var cachedStdlibZip = new Uint8Array(readFileSync(stdlibZipPath));
+function postWorkerMessage(message) {
+  try {
+    parentPort?.postMessage(message);
+  } catch (error) {
+    console.debug(
+      "[python3-worker] failed to post worker message:",
+      sanitizeUnknownError(error)
+    );
+  }
+}
 async function runPython(input) {
   const backend = new SyncFsBackend(input.sharedBuffer);
   const createPythonModule = require2(`${cpythonDir}/python.cjs`);
@@ -2551,17 +2659,20 @@ async function runPython(input) {
   const pendingStderr = [];
   let Module;
   try {
-    Module = await createPythonModule({
-      noInitialRun: true,
-      preRun: [
-        (mod) => {
-          mod.FS.mkdirTree("/lib");
-          mod.FS.writeFile("/lib/python313.zip", cachedStdlibZip);
-          mod.ENV.PYTHONHOME = "/";
-          mod.ENV.PYTHONPATH = "/lib/python313.zip";
-        }
-      ],
-      print: (text) => {
+    const onPreRun = wrapWasmCallback(
+      "python3-worker",
+      "preRun",
+      (mod) => {
+        mod.FS.mkdirTree("/lib");
+        mod.FS.writeFile("/lib/python313.zip", cachedStdlibZip);
+        mod.ENV.PYTHONHOME = "/";
+        mod.ENV.PYTHONPATH = "/lib/python313.zip";
+      }
+    );
+    const onPrint = wrapWasmCallback(
+      "python3-worker",
+      "print",
+      (text) => {
         if (moduleReady) {
           backend.writeStdout(`${text}
 `);
@@ -2569,8 +2680,12 @@ async function runPython(input) {
           pendingStdout.push(`${text}
 `);
         }
-      },
-      printErr: (text) => {
+      }
+    );
+    const onPrintErr = wrapWasmCallback(
+      "python3-worker",
+      "printErr",
+      (text) => {
         if (typeof text === "string" && (text.includes("Could not find platform") || text.includes("LLVM Profile Error"))) {
           return;
         }
@@ -2582,11 +2697,18 @@ async function runPython(input) {
 `);
         }
       }
+    );
+    Module = await createPythonModule({
+      noInitialRun: true,
+      preRun: [onPreRun],
+      print: onPrint,
+      printErr: onPrintErr
     });
   } catch (e) {
+    const message = sanitizeErrorMessage(e.message);
     return {
       success: false,
-      error: `Failed to load CPython: ${e.message}`
+      error: `Failed to load CPython: ${message}`
     };
   }
   activateDefense();
@@ -2598,9 +2720,10 @@ async function runPython(input) {
     Module.FS.mkdir("/host");
     Module.FS.mount(HOSTFS, { root: "/" }, "/host");
   } catch (e) {
+    const message = sanitizeErrorMessage(e.message);
     return {
       success: false,
-      error: `Failed to mount HOSTFS: ${e.message}`
+      error: `Failed to mount HOSTFS: ${message}`
     };
   }
   const HTTPFS = createHTTPFS(backend, Module.FS);
@@ -2608,9 +2731,10 @@ async function runPython(input) {
     Module.FS.mkdir("/_jb_http");
     Module.FS.mount(HTTPFS, { root: "/" }, "/_jb_http");
   } catch (e) {
+    const message = sanitizeErrorMessage(e.message);
     return {
       success: false,
-      error: `Failed to mount HTTPFS: ${e.message}`
+      error: `Failed to mount HTTPFS: ${message}`
     };
   }
   const setupCode = generateSetupCode(input);
@@ -2660,6 +2784,13 @@ function activateDefense() {
     writable: true,
     configurable: true
   });
+  const onViolation = wrapWasmCallback(
+    "python3-worker",
+    "onViolation",
+    (v) => {
+      postWorkerMessage({ type: "security-violation", violation: v });
+    }
+  );
   defense = new WorkerDefenseInDepth({
     excludeViolationTypes: [
       // SharedArrayBuffer/Atomics: Used by sync-fs-backend.ts for synchronous
@@ -2670,26 +2801,26 @@ function activateDefense() {
       // stub. Defense doesn't need to block it — it's already degraded.
       "performance_timing"
     ],
-    onViolation: (v) => {
-      parentPort?.postMessage({ type: "security-violation", violation: v });
-    }
+    onViolation
   });
 }
 process.on("uncaughtException", (e) => {
-  parentPort?.postMessage({
+  const message = sanitizeErrorMessage(e.message);
+  postWorkerMessage({
     success: false,
-    error: `Worker uncaught exception: ${e.message}`
+    error: `Worker uncaught exception: ${message}`
   });
 });
 if (parentPort) {
   if (workerData) {
     runPython(workerData).then((result) => {
       result.defenseStats = defense?.getStats();
-      parentPort?.postMessage(result);
+      postWorkerMessage(result);
     }).catch((e) => {
-      parentPort?.postMessage({
+      const message = sanitizeUnknownError(e);
+      postWorkerMessage({
         success: false,
-        error: e.message,
+        error: message,
         defenseStats: defense?.getStats()
       });
     });

package/dist/bundle/chunks/xan-LAW2EMOM.js

@@ -0,0 +1 @@
+import{a,b}from"./chunk-CBAJ47B3.js";import"./chunk-F55TLFGB.js";import"./chunk-SYMJJMQ4.js";import"./chunk-QI4EPYAT.js";import"./chunk-7MKBHGLS.js";import"./chunk-OJDRYQWQ.js";import"./chunk-L75XCEQX.js";import"./chunk-FD7SFJNJ.js";import"./chunk-YNYSPYQ5.js";import"./chunk-7L36YK2X.js";import"./chunk-GFQRA5P5.js";import"./chunk-NUFRM6SI.js";import"./chunk-74CEPOFO.js";import"./chunk-DXB73IDG.js";export{b as flagsForFuzzing,a as xanCommand};

package/dist/bundle/chunks/yq-MFJEXB7R.js

@@ -0,0 +1 @@
+import{a,b}from"./chunk-3J4BCKUH.js";import"./chunk-SYMJJMQ4.js";import"./chunk-QI4EPYAT.js";import"./chunk-7MKBHGLS.js";import"./chunk-OJDRYQWQ.js";import"./chunk-L75XCEQX.js";import"./chunk-FD7SFJNJ.js";import"./chunk-YNYSPYQ5.js";import"./chunk-GFQRA5P5.js";import"./chunk-CCNMISUL.js";import"./chunk-74CEPOFO.js";import"./chunk-DXB73IDG.js";export{b as flagsForFuzzing,a as yqCommand};