just-bash 2.9.3 → 2.9.5

package/dist/bundle/chunks/worker.js

@@ -1,3 +1,10 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
 // src/commands/python3/worker.ts
 import { parentPort, workerData } from "node:worker_threads";
 import { loadPyodide } from "pyodide";
@@ -75,6 +82,9 @@ function getBlockedGlobals() {
       strategy: "throw",
       reason: "process.dlopen allows loading native addons"
     },
+    // Note: process.mainModule is handled specially in defense-in-depth-box.ts
+    // and worker-defense-in-depth.ts because it may be undefined in ESM contexts
+    // but we still want to block both reading and setting it.
     // We also don't block `require` because:
     // 1. It may not exist in all environments (ESM)
     // 2. import() is the modern escape vector and can't be blocked this way
@@ -115,6 +125,21 @@ function getBlockedGlobals() {
       violationType: "webassembly",
       strategy: "throw",
       reason: "WebAssembly allows executing arbitrary compiled code"
+    },
+    // SharedArrayBuffer and Atomics can enable side-channel attacks
+    {
+      prop: "SharedArrayBuffer",
+      target: globalThis,
+      violationType: "shared_array_buffer",
+      strategy: "throw",
+      reason: "SharedArrayBuffer could enable side-channel communication or timing attacks"
+    },
+    {
+      prop: "Atomics",
+      target: globalThis,
+      violationType: "atomics",
+      strategy: "throw",
+      reason: "Atomics could enable side-channel communication or timing attacks"
     }
     // Note: Error.prepareStackTrace is handled specially in defense-in-depth-box.ts
     // because we only want to block SETTING it, not reading (V8 reads it internally)
@@ -491,6 +516,12 @@ var WorkerDefenseInDepth = class {
     if (!excludeTypes.has("error_prepare_stack_trace")) {
       this.protectErrorPrepareStackTrace();
     }
+    if (!excludeTypes.has("module_load")) {
+      this.protectModuleLoad();
+    }
+    if (!excludeTypes.has("process_main_module")) {
+      this.protectProcessMainModule();
+    }
   }
   /**
    * Protect against .constructor.constructor escape vector.
@@ -665,6 +696,123 @@ var WorkerDefenseInDepth = class {
     } catch {
     }
   }
+  /**
+   * Protect process.mainModule from being accessed or set.
+   *
+   * The attack vector is:
+   * ```
+   * process.mainModule.require('child_process').execSync('whoami')
+   * process.mainModule.constructor._load('vm')
+   * ```
+   *
+   * process.mainModule may be undefined in ESM contexts but could exist in
+   * CommonJS workers. We block both reading and setting.
+   */
+  protectProcessMainModule() {
+    if (typeof process === "undefined") return;
+    const self = this;
+    const auditMode = this.config.auditMode;
+    try {
+      const originalDescriptor = Object.getOwnPropertyDescriptor(
+        process,
+        "mainModule"
+      );
+      this.originalDescriptors.push({
+        target: process,
+        prop: "mainModule",
+        descriptor: originalDescriptor
+      });
+      const currentValue = originalDescriptor?.value;
+      if (currentValue !== void 0) {
+        Object.defineProperty(process, "mainModule", {
+          get() {
+            const message = "process.mainModule access is blocked in worker context";
+            const violation = self.recordViolation(
+              "process_main_module",
+              "process.mainModule",
+              message
+            );
+            if (!auditMode) {
+              throw new WorkerSecurityViolationError(message, violation);
+            }
+            return currentValue;
+          },
+          set(value) {
+            const message = "process.mainModule modification is blocked in worker context";
+            const violation = self.recordViolation(
+              "process_main_module",
+              "process.mainModule",
+              message
+            );
+            if (!auditMode) {
+              throw new WorkerSecurityViolationError(message, violation);
+            }
+            Object.defineProperty(process, "mainModule", {
+              value,
+              writable: true,
+              configurable: true
+            });
+          },
+          configurable: true
+        });
+      }
+    } catch {
+    }
+  }
+  /**
+   * Protect Module._load from being called.
+   *
+   * The attack vector is:
+   * ```
+   * module.constructor._load('child_process')
+   * require.main.constructor._load('vm')
+   * ```
+   *
+   * We access the Module class and replace _load with a blocking proxy.
+   */
+  protectModuleLoad() {
+    const self = this;
+    const auditMode = this.config.auditMode;
+    try {
+      let ModuleClass = null;
+      if (typeof process !== "undefined") {
+        const mainModule = process.mainModule;
+        if (mainModule && typeof mainModule === "object") {
+          ModuleClass = mainModule.constructor;
+        }
+      }
+      if (!ModuleClass && typeof __require !== "undefined" && typeof __require.main !== "undefined") {
+        ModuleClass = __require.main.constructor;
+      }
+      if (!ModuleClass || typeof ModuleClass._load !== "function") {
+        return;
+      }
+      const original = ModuleClass._load;
+      const descriptor = Object.getOwnPropertyDescriptor(ModuleClass, "_load");
+      this.originalDescriptors.push({
+        target: ModuleClass,
+        prop: "_load",
+        descriptor
+      });
+      const path = "Module._load";
+      const proxy = new this.originalProxy(original, {
+        apply(_target, _thisArg, _args) {
+          const message = `${path} is blocked in worker context`;
+          const violation = self.recordViolation("module_load", path, message);
+          if (!auditMode) {
+            throw new WorkerSecurityViolationError(message, violation);
+          }
+          return Reflect.apply(_target, _thisArg, _args);
+        }
+      });
+      Object.defineProperty(ModuleClass, "_load", {
+        value: proxy,
+        writable: true,
+        configurable: true
+      });
+    } catch {
+    }
+  }
   /**
    * Apply a single patch to a blocked global.
    */
@@ -2062,7 +2210,15 @@ var defense = null;
 async function initializeWithDefense() {
   await getPyodide();
   defense = new WorkerDefenseInDepth({
-    excludeViolationTypes: ["proxy", "setImmediate"],
+    excludeViolationTypes: [
+      "proxy",
+      "setImmediate",
+      // 3. SharedArrayBuffer/Atomics: Used by sync-fs-backend.ts for synchronous
+      //    filesystem communication between Pyodide's WASM thread and the main thread.
+      //    Without this, Pyodide cannot perform synchronous file I/O operations.
+      "shared_array_buffer",
+      "atomics"
+    ],
     onViolation: (v) => {
       parentPort?.postMessage({ type: "security-violation", violation: v });
     }

package/dist/bundle/chunks/xan-6DLWA2BW.js

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

package/dist/bundle/chunks/xargs-OGI2NN6J.js

@@ -0,0 +1 @@
+import{a,b}from"./chunk-SXR3EI72.js";import"./chunk-74CEPOFO.js";import"./chunk-DXB73IDG.js";export{b as flagsForFuzzing,a as xargsCommand};

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

@@ -0,0 +1 @@
+import{a,b}from"./chunk-GOBUJIHS.js";import"./chunk-SYMJJMQ4.js";import"./chunk-RSXSWZBQ.js";import"./chunk-7MKBHGLS.js";import"./chunk-OJDRYQWQ.js";import"./chunk-YNYSPYQ5.js";import"./chunk-PSW6BMXW.js";import"./chunk-74CEPOFO.js";import"./chunk-DXB73IDG.js";export{b as flagsForFuzzing,a as yqCommand};