just-bash 2.12.0 → 2.12.2

package/dist/bin/chunks/worker.js

@@ -277,9 +277,80 @@ function getBlockedGlobals() {
       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)
+    // Timing side-channel: performance.now() provides sub-millisecond resolution
+    // Note: Date.now() is intentionally NOT blocked — it's used for $SECONDS,
+    // date command, and has only ~1ms resolution (vs process.hrtime at ns).
+    {
+      prop: "performance",
+      target: globalThis,
+      violationType: "performance_timing",
+      strategy: "throw",
+      reason: "performance.now() provides sub-millisecond timing for side-channel attacks"
+    },
+    // Block direct access to process.stdout and process.stderr to prevent
+    // writing to the host's actual stdout/stderr, bypassing the interpreter's
+    // output accumulation.
+    {
+      prop: "stdout",
+      target: process,
+      violationType: "process_stdout",
+      strategy: "throw",
+      reason: "process.stdout could bypass interpreter output to write to host stdout"
+    },
+    {
+      prop: "stderr",
+      target: process,
+      violationType: "process_stderr",
+      strategy: "throw",
+      reason: "process.stderr could bypass interpreter output to write to host stderr"
+    },
+    // Prototype pollution vectors
+    {
+      prop: "__defineGetter__",
+      target: Object.prototype,
+      violationType: "prototype_mutation",
+      strategy: "throw",
+      reason: "__defineGetter__ allows prototype pollution via getter injection"
+    },
+    {
+      prop: "__defineSetter__",
+      target: Object.prototype,
+      violationType: "prototype_mutation",
+      strategy: "throw",
+      reason: "__defineSetter__ allows prototype pollution via setter injection"
+    },
+    {
+      prop: "__lookupGetter__",
+      target: Object.prototype,
+      violationType: "prototype_mutation",
+      strategy: "throw",
+      reason: "__lookupGetter__ enables introspection for prototype pollution attacks"
+    },
+    {
+      prop: "__lookupSetter__",
+      target: Object.prototype,
+      violationType: "prototype_mutation",
+      strategy: "throw",
+      reason: "__lookupSetter__ enables introspection for prototype pollution attacks"
+    },
+    // Freeze JSON and Math to prevent mutation of built-in utility objects
+    {
+      prop: "JSON",
+      target: globalThis,
+      violationType: "json_mutation",
+      strategy: "freeze",
+      reason: "Freeze JSON to prevent mutation of parsing/serialization"
+    },
+    {
+      prop: "Math",
+      target: globalThis,
+      violationType: "math_mutation",
+      strategy: "freeze",
+      reason: "Freeze Math to prevent mutation of math utilities"
+    }
   ];
   try {
     const AsyncFunction = Object.getPrototypeOf(async () => {
@@ -650,6 +721,9 @@ var WorkerDefenseInDepth = class {
     if (!excludeTypes.has("module_load")) {
       this.protectModuleLoad();
     }
+    if (!excludeTypes.has("module_resolve_filename")) {
+      this.protectModuleResolveFilename();
+    }
     if (!excludeTypes.has("process_main_module")) {
       this.protectProcessMainModule();
     }
@@ -1065,6 +1139,65 @@ var WorkerDefenseInDepth = class {
     } catch {
     }
   }
+  /**
+   * Protect Module._resolveFilename from being called in worker context.
+   *
+   * Module._resolveFilename is called for both require() and import() resolution.
+   * Blocking it catches file-based import() specifiers.
+   *
+   * data: and blob: URLs are handled by ESM loader hooks registered
+   * in the main thread (DefenseInDepthBox.protectDynamicImport).
+   */
+  protectModuleResolveFilename() {
+    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._resolveFilename !== "function") {
+        return;
+      }
+      const original = ModuleClass._resolveFilename;
+      const descriptor = Object.getOwnPropertyDescriptor(
+        ModuleClass,
+        "_resolveFilename"
+      );
+      this.originalDescriptors.push({
+        target: ModuleClass,
+        prop: "_resolveFilename",
+        descriptor
+      });
+      const path = "Module._resolveFilename";
+      const proxy = new this.originalProxy(original, {
+        apply(_target, _thisArg, _args) {
+          const message = `${path} is blocked in worker context`;
+          const violation = self.recordViolation(
+            "module_resolve_filename",
+            path,
+            message
+          );
+          if (!auditMode) {
+            throw new WorkerSecurityViolationError(message, violation);
+          }
+          return Reflect.apply(_target, _thisArg, _args);
+        }
+      });
+      Object.defineProperty(ModuleClass, "_resolveFilename", {
+        value: proxy,
+        writable: true,
+        configurable: true
+      });
+    } catch {
+    }
+  }
   /**
    * Apply a single patch to a blocked global.
    */
@@ -1125,6 +1258,7 @@ var _setTimeout = globalThis.setTimeout;
 var _clearTimeout = globalThis.clearTimeout;
 var _SharedArrayBuffer = globalThis.SharedArrayBuffer;
 var _Atomics = globalThis.Atomics;
+var _performanceNow = performance.now.bind(performance);
 
 // src/commands/python3/protocol.ts
 var OpCode = {
@@ -1548,11 +1682,17 @@ var SyncFsBackend = class {
   }
   writeStdout(data) {
     const encoded = new TextEncoder().encode(data);
-    this.execSync(OpCode.WRITE_STDOUT, "", encoded);
+    const result = this.execSync(OpCode.WRITE_STDOUT, "", encoded);
+    if (!result.success) {
+      throw new Error(result.error || "Failed to write stdout");
+    }
   }
   writeStderr(data) {
     const encoded = new TextEncoder().encode(data);
-    this.execSync(OpCode.WRITE_STDERR, "", encoded);
+    const result = this.execSync(OpCode.WRITE_STDERR, "", encoded);
+    if (!result.success) {
+      throw new Error(result.error || "Failed to write stderr");
+    }
   }
   exit(code) {
     this.execSync(OpCode.EXIT, "", void 0, code);
@@ -2513,12 +2653,22 @@ sys.exit(_jb_exit_code)
 var defense = null;
 function activateDefense() {
   if (defense) return;
+  const _DateNow = Date.now;
+  const degraded = { now: () => _DateNow(), timeOrigin: _DateNow() };
+  Object.defineProperty(globalThis, "performance", {
+    value: degraded,
+    writable: true,
+    configurable: true
+  });
   defense = new WorkerDefenseInDepth({
     excludeViolationTypes: [
       // SharedArrayBuffer/Atomics: Used by sync-fs-backend.ts for synchronous
       // filesystem communication between the WASM thread and the main thread.
       "shared_array_buffer",
-      "atomics"
+      "atomics",
+      // performance: Excluded because we replaced it above with a ms-precision
+      // stub. Defense doesn't need to block it — it's already degraded.
+      "performance_timing"
     ],
     onViolation: (v) => {
       parentPort?.postMessage({ type: "security-violation", violation: v });

package/dist/bin/{shell/chunks/xargs-YWPEV2QC.js → chunks/xargs-GBL6PZ2K.js}

@@ -1,2 +1,2 @@
 #!/usr/bin/env node
-import{a,b}from"./chunk-JXC25GVQ.js";import"./chunk-GTNBSMZR.js";import"./chunk-KGOUQS5A.js";export{b as flagsForFuzzing,a as xargsCommand};
+import{a,b}from"./chunk-47HZU3SY.js";import"./chunk-GTNBSMZR.js";import"./chunk-KGOUQS5A.js";export{b as flagsForFuzzing,a as xargsCommand};