just-bash 3.1.0 → 3.2.0

package/dist/commands/sqlite3/worker.js

@@ -34,6 +34,10 @@ function sanitizeHostErrorMessage(message) {
   return sanitizeWithUnixPrefixes(message, true, true);
 }
 
+// src/security/defense-in-depth-box.ts
+import * as nodeAsyncHooks from "node:async_hooks";
+import * as nodeModule from "node:module";
+
 // src/security/blocked-globals.ts
 function getBlockedGlobals() {
   const globals = [
@@ -268,6 +272,21 @@ function getBlockedGlobals() {
       strategy: "throw",
       reason: "setUncaughtExceptionCaptureCallback could intercept security errors"
     },
+    ...[
+      "on",
+      "once",
+      "addListener",
+      "prependListener",
+      "prependOnceListener"
+    ].map(
+      (prop) => ({
+        prop,
+        target: process,
+        violationType: "process_exception_handler",
+        strategy: "throw",
+        reason: "process-global listeners can outlive the sandbox and lose its security context"
+      })
+    ),
     // IPC communication vectors (may be undefined in non-IPC contexts)
     {
       prop: "send",
@@ -504,10 +523,13 @@ function getBlockedGlobals() {
 // src/security/defense-in-depth-box.ts
 var IS_BROWSER = typeof __BROWSER__ !== "undefined" && __BROWSER__;
 var AsyncLocalStorageClass = null;
+var nodeModuleApi = null;
+var nodeModuleClass = null;
 if (!IS_BROWSER) {
   try {
-    const { AsyncLocalStorage } = __require("node:async_hooks");
-    AsyncLocalStorageClass = AsyncLocalStorage;
+    AsyncLocalStorageClass = nodeAsyncHooks.AsyncLocalStorage;
+    nodeModuleApi = nodeModule;
+    nodeModuleClass = nodeModuleApi.Module ?? nodeModuleApi.default ?? null;
   } catch {
   }
 }
@@ -524,6 +546,25 @@ var WorkerSecurityViolationError = class extends Error {
   violation;
 };
 var MAX_STORED_VIOLATIONS = 1e3;
+var nodeModuleClass2 = null;
+try {
+  const getBuiltinModule = process.getBuiltinModule;
+  const moduleApi = typeof getBuiltinModule === "function" ? getBuiltinModule("module") : typeof __require === "function" ? (
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    __require("node:module")
+  ) : null;
+  nodeModuleClass2 = moduleApi?.Module ?? moduleApi?.default ?? null;
+  if (typeof getBuiltinModule === "function") {
+    const workerThreads = getBuiltinModule("worker_threads");
+    const isWorkerThread = workerThreads?.isMainThread === false;
+    if (isWorkerThread) {
+      const cryptoApi = getBuiltinModule("crypto");
+      cryptoApi?.randomUUID?.();
+    }
+  }
+} catch {
+  nodeModuleClass2 = null;
+}
 function generateExecutionId() {
   if (typeof crypto !== "undefined" && crypto.randomUUID) {
     return crypto.randomUUID();
@@ -538,6 +579,7 @@ var WorkerDefenseInDepth = class {
   config;
   isActivated = false;
   originalDescriptors = [];
+  patchFailures = [];
   violations = [];
   executionId;
   /**
@@ -603,8 +645,14 @@ var WorkerDefenseInDepth = class {
     if (this.isActivated) {
       return;
     }
-    this.applyPatches();
-    this.isActivated = true;
+    try {
+      this.applyPatches();
+      this.isActivated = true;
+    } catch (error) {
+      this.restorePatches();
+      this.isActivated = false;
+      throw error;
+    }
   }
   /**
    * Get a human-readable path for a target object and property.
@@ -852,16 +900,64 @@ var WorkerDefenseInDepth = class {
       }
     });
   }
+  createReadonlyObjectProxy(original, path, violationType) {
+    const auditMode = this.config.auditMode;
+    const allowOrThrow = (operation) => {
+      const message = `${path} ${operation} is blocked in worker context`;
+      const violation = this.recordViolation(violationType, path, message);
+      if (!auditMode) {
+        throw new WorkerSecurityViolationError(message, violation);
+      }
+    };
+    return new this.originalProxy(original, {
+      set(target, prop, value, receiver) {
+        allowOrThrow("modification");
+        return Reflect.set(target, prop, value, receiver);
+      },
+      defineProperty(target, prop, descriptor) {
+        allowOrThrow("defineProperty");
+        return Reflect.defineProperty(target, prop, descriptor);
+      },
+      deleteProperty(target, prop) {
+        allowOrThrow("deletion");
+        return Reflect.deleteProperty(target, prop);
+      },
+      setPrototypeOf(target, prototype) {
+        allowOrThrow("setPrototypeOf");
+        return Reflect.setPrototypeOf(target, prototype);
+      },
+      preventExtensions(target) {
+        allowOrThrow("preventExtensions");
+        return Reflect.preventExtensions(target);
+      }
+    });
+  }
   /**
    * Apply security patches to dangerous globals.
    */
   applyPatches() {
+    this.patchFailures = [];
     const blockedGlobals = getBlockedGlobals();
     const excludeTypes = new Set(this.config.excludeViolationTypes ?? []);
+    const workerInfrastructureListenerMethods = /* @__PURE__ */ new Set([
+      "on",
+      "once",
+      "addListener",
+      "prependListener",
+      "prependOnceListener"
+    ]);
+    const permanentIntrinsicPatches = [];
     for (const blocked of blockedGlobals) {
       if (excludeTypes.has(blocked.violationType)) {
         continue;
       }
+      if (blocked.target === process && workerInfrastructureListenerMethods.has(blocked.prop)) {
+        continue;
+      }
+      if (blocked.strategy === "freeze") {
+        permanentIntrinsicPatches.push(blocked);
+        continue;
+      }
       this.applyPatch(blocked);
     }
     if (!excludeTypes.has("function_constructor")) {
@@ -885,10 +981,27 @@ var WorkerDefenseInDepth = class {
     if (!excludeTypes.has("process_connected")) {
       this.protectProcessConnected();
     }
-    this.lockWellKnownSymbols();
     if (!excludeTypes.has("proxy")) {
       this.protectProxyRevocable();
     }
+    const criticalPaths = [
+      "Function.prototype.constructor",
+      "Module._load",
+      "Module._resolveFilename"
+    ];
+    const criticalFailures = this.patchFailures.filter(
+      (path) => criticalPaths.includes(path)
+    );
+    if (criticalFailures.length > 0) {
+      this.restorePatches();
+      throw new Error(
+        `WorkerDefenseInDepth: critical patches failed: ${criticalFailures.join(", ")}`
+      );
+    }
+    for (const blocked of permanentIntrinsicPatches) {
+      this.applyPatch(blocked);
+    }
+    this.lockWellKnownSymbols();
   }
   /**
    * Lock well-known Symbol properties on built-in constructors/prototypes.
@@ -943,23 +1056,6 @@ var WorkerDefenseInDepth = class {
     ]) {
       lock(proto, Symbol.toStringTag);
     }
-    try {
-      const stackDesc = Object.getOwnPropertyDescriptor(
-        Error,
-        "stackTraceLimit"
-      );
-      this.originalDescriptors.push({
-        target: Error,
-        prop: "stackTraceLimit",
-        descriptor: stackDesc
-      });
-      Object.defineProperty(Error, "stackTraceLimit", {
-        value: Error.stackTraceLimit,
-        writable: false,
-        configurable: true
-      });
-    } catch {
-    }
   }
   /**
    * Block Proxy.revocable to prevent bypassing Proxy constructor blocking.
@@ -1174,6 +1270,7 @@ var WorkerDefenseInDepth = class {
         configurable: true
       });
     } catch {
+      this.patchFailures.push(path);
     }
   }
   /**
@@ -1366,47 +1463,7 @@ var WorkerDefenseInDepth = class {
    * 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 {
-    }
+    this.protectModuleMethod("_load", "module_load");
   }
   /**
    * Protect Module._resolveFilename from being called in worker context.
@@ -1418,53 +1475,55 @@ var WorkerDefenseInDepth = class {
    * in the main thread (DefenseInDepthBox.protectDynamicImport).
    */
   protectModuleResolveFilename() {
+    this.protectModuleMethod("_resolveFilename", "module_resolve_filename");
+  }
+  protectModuleMethod(prop, violationType) {
+    const path = `Module.${prop}`;
     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;
-        }
+      const ModuleClass = nodeModuleClass2;
+      const original = ModuleClass?.[prop];
+      if (!ModuleClass || typeof original !== "function") {
+        throw new Error("node:module Module class or method is unavailable");
       }
-      if (!ModuleClass && typeof __require !== "undefined" && typeof __require.main !== "undefined") {
-        ModuleClass = __require.main.constructor;
+      const descriptor = Object.getOwnPropertyDescriptor(ModuleClass, prop);
+      if (!descriptor) throw new Error("method descriptor is unavailable");
+      if (descriptor.configurable === false && descriptor.writable === false) {
+        throw new Error("method is non-configurable and non-writable");
       }
-      if (!ModuleClass || typeof ModuleClass._resolveFilename !== "function") {
-        return;
-      }
-      const original = ModuleClass._resolveFilename;
-      const descriptor = Object.getOwnPropertyDescriptor(
-        ModuleClass,
-        "_resolveFilename"
+      const proxy = new this.originalProxy(
+        original,
+        {
+          apply(target, thisArg, args) {
+            const message = `${path} is blocked in worker context`;
+            const violation = self.recordViolation(
+              violationType,
+              path,
+              message
+            );
+            if (!auditMode) {
+              throw new WorkerSecurityViolationError(message, violation);
+            }
+            return Reflect.apply(target, thisArg, args);
+          }
+        }
       );
       this.originalDescriptors.push({
         target: ModuleClass,
-        prop: "_resolveFilename",
+        prop,
         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
+      Object.defineProperty(ModuleClass, prop, {
+        ...descriptor,
+        value: proxy
       });
+      const installed = Object.getOwnPropertyDescriptor(ModuleClass, prop);
+      if (ModuleClass[prop] !== proxy || installed?.value !== proxy) {
+        throw new Error("installed patch failed verification");
+      }
     } catch {
+      this.patchFailures.push(path);
     }
   }
   /**
@@ -1482,6 +1541,16 @@ var WorkerDefenseInDepth = class {
       if (strategy === "freeze") {
         if (typeof original === "object" && original !== null) {
           Object.freeze(original);
+          const path = this.getPathForTarget(target, prop);
+          const proxy = this.createReadonlyObjectProxy(
+            original,
+            path,
+            violationType
+          );
+          Object.defineProperty(target, prop, {
+            ...descriptor,
+            value: proxy
+          });
         }
       } else {
         const path = this.getPathForTarget(target, prop);
@@ -1528,18 +1597,10 @@ 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/commands/sqlite3/worker.ts
+var MIN_SQLITE_HEAP_LIMIT = 32 * 1024 * 1024;
+var MAX_SQLITE_HEAP_LIMIT = 128 * 1024 * 1024;
 var cachedSQL = null;
 var defense = null;
 function wrapWorkerMessage(protocolToken, message) {
@@ -1565,24 +1626,17 @@ function postWorkerMessage(protocolToken, message) {
     );
   }
 }
-async function initializeWithDefense(protocolToken) {
+async function initializeSqlJs() {
   if (cachedSQL) {
     return cachedSQL;
   }
   cachedSQL = await initSqlJs();
-  const onViolation = wrapWasmCallback(
-    "sqlite3-worker",
-    "onViolation",
-    (v) => {
-      postWorkerMessage(protocolToken, {
-        type: "security-violation",
-        violation: v
-      });
-    }
-  );
-  defense = new WorkerDefenseInDepth({ onViolation });
   return cachedSQL;
 }
+function activateDefense() {
+  if (defense) return;
+  defense = new WorkerDefenseInDepth({});
+}
 function stripLeadingNoise(sql) {
   let s = sql;
   for (; ; ) {
@@ -1603,57 +1657,106 @@ function isReadOnlyStatement(sql) {
   if (s.startsWith("SELECT")) return true;
   if (s.startsWith("EXPLAIN")) return true;
   if (s.startsWith("VALUES")) return true;
-  if (s.startsWith("PRAGMA")) {
-    const rest = s.slice("PRAGMA".length);
-    return !/[=(]/.test(rest);
-  }
   return false;
 }
-function isWriteStatement(sql) {
-  const trimmed = stripLeadingNoise(sql).toUpperCase();
-  return trimmed.startsWith("INSERT") || trimmed.startsWith("UPDATE") || trimmed.startsWith("DELETE") || trimmed.startsWith("CREATE") || trimmed.startsWith("DROP") || trimmed.startsWith("ALTER") || trimmed.startsWith("REPLACE") || trimmed.startsWith("VACUUM");
-}
-function splitStatements(sql) {
-  const statements = [];
-  let current = "";
-  let inString = false;
-  let stringChar = "";
+function tailAfterFailedPrepare(db, sql) {
+  let quote = null;
+  let lineComment = false;
+  let blockComment = false;
   for (let i = 0; i < sql.length; i++) {
     const char = sql[i];
-    if (inString) {
-      current += char;
-      if (char === stringChar) {
-        if (sql[i + 1] === stringChar) {
-          current += sql[++i];
-        } else {
-          inString = false;
-        }
+    const next = sql[i + 1];
+    if (lineComment) {
+      if (char === "\n") lineComment = false;
+      continue;
+    }
+    if (blockComment) {
+      if (char === "*" && next === "/") {
+        blockComment = false;
+        i++;
       }
-    } else if (char === "'" || char === '"') {
-      current += char;
-      inString = true;
-      stringChar = char;
-    } else if (char === ";") {
-      const stmt2 = current.trim();
-      if (stmt2) statements.push(stmt2);
-      current = "";
-    } else {
-      current += char;
+      continue;
+    }
+    if (quote !== null) {
+      const closes = quote === "]" ? char === "]" : char === quote;
+      if (closes) {
+        if (quote !== "]" && next === quote) i++;
+        else quote = null;
+      }
+      continue;
+    }
+    if (char === "-" && next === "-") {
+      lineComment = true;
+      i++;
+      continue;
+    }
+    if (char === "/" && next === "*") {
+      blockComment = true;
+      i++;
+      continue;
+    }
+    if (char === "'" || char === '"' || char === "`") {
+      quote = char;
+      continue;
+    }
+    if (char === "[") {
+      quote = "]";
+      continue;
+    }
+    if (char !== ";") continue;
+    const prefix = sql.slice(0, i + 1);
+    try {
+      const statement = db.prepare(prefix);
+      statement.free();
+      return sql.slice(i + 1);
+    } catch (error) {
+      if (!/incomplete input/i.test(error.message))
+        return sql.slice(i + 1);
     }
   }
-  const stmt = current.trim();
-  if (stmt) statements.push(stmt);
-  return statements;
+  return null;
+}
+function valueByteLength(value) {
+  if (value === null || value === void 0) return 4;
+  if (value instanceof Uint8Array) return value.byteLength;
+  if (typeof value === "string") return Buffer.byteLength(value, "utf8");
+  return Buffer.byteLength(String(value), "utf8");
+}
+function databaseByteLength(db) {
+  const pageCount = db.exec("PRAGMA page_count")[0]?.values[0]?.[0];
+  const pageSize = db.exec("PRAGMA page_size")[0]?.values[0]?.[0];
+  if (typeof pageCount !== "number" || typeof pageSize !== "number") return 0;
+  return pageCount * pageSize;
 }
 async function executeQuery(data) {
   let db;
   try {
-    const SQL = await initializeWithDefense(data.protocolToken);
+    if (data.dbBuffer && data.dbBuffer.byteLength > data.limits.maxDatabaseBytes) {
+      throw new Error(
+        `database exceeds ${data.limits.maxDatabaseBytes} byte limit`
+      );
+    }
+    const SQL = await initializeSqlJs();
     if (data.dbBuffer) {
       db = new SQL.Database(data.dbBuffer);
     } else {
       db = new SQL.Database();
     }
+    const sqliteHeapLimit = Math.min(
+      MAX_SQLITE_HEAP_LIMIT,
+      Math.max(
+        MIN_SQLITE_HEAP_LIMIT,
+        (data.dbBuffer?.byteLength ?? 0) + data.limits.maxResultBytes * 2
+      )
+    );
+    db.run(`PRAGMA hard_heap_limit = ${sqliteHeapLimit}`);
+    const bootstrapIterator = db.iterateStatements("SELECT 1");
+    const bootstrapStatement = bootstrapIterator.next();
+    if (!bootstrapStatement.done) {
+      bootstrapStatement.value.step();
+      bootstrapStatement.value.free();
+    }
+    activateDefense();
   } catch (e) {
     const message = sanitizeHostErrorMessage(e.message);
     return {
@@ -1664,37 +1767,77 @@ async function executeQuery(data) {
   }
   const results = [];
   let hasModifications = false;
+  let resultRows = 0;
+  let resultBytes = 0;
   try {
-    const statements = splitStatements(data.sql);
-    for (const stmt of statements) {
+    let remainingSql = data.sql;
+    while (remainingSql.trim().length > 0) {
+      let prepared;
+      const iterator = db.iterateStatements(remainingSql);
       try {
-        if (isWriteStatement(stmt)) {
-          db.run(stmt);
-          hasModifications = true;
-          results.push({ type: "data", columns: [], rows: [] });
-        } else {
-          const prepared = db.prepare(stmt);
-          const columns = prepared.getColumnNames();
-          const rows = [];
-          while (prepared.step()) {
-            rows.push(prepared.get());
+        const next = iterator.next();
+        if (next.done) break;
+        prepared = next.value;
+        remainingSql = iterator.getRemainingSQL();
+      } catch (e) {
+        const message = sanitizeHostErrorMessage(e.message);
+        results.push({
+          type: "error",
+          error: message
+        });
+        if (data.options.bail) break;
+        let tail = iterator.getRemainingSQL();
+        if (tail === remainingSql)
+          tail = tailAfterFailedPrepare(db, remainingSql) ?? remainingSql;
+        if (tail === remainingSql) break;
+        remainingSql = tail;
+        continue;
+      }
+      const stmt = prepared.getSQL();
+      try {
+        const columns = prepared.getColumnNames();
+        for (const column of columns) {
+          resultBytes += Buffer.byteLength(column, "utf8");
+        }
+        const rows = [];
+        while (prepared.step()) {
+          if (resultRows >= data.limits.maxResultRows) {
+            throw new Error(
+              `query result exceeds ${data.limits.maxResultRows} row limit`
+            );
           }
-          prepared.free();
-          results.push({ type: "data", columns, rows });
-          if (!isReadOnlyStatement(stmt)) {
-            hasModifications = true;
+          const row = prepared.get();
+          let rowBytes = row.length * 8;
+          for (const value of row) rowBytes += valueByteLength(value);
+          if (resultBytes + rowBytes > data.limits.maxResultBytes) {
+            throw new Error(
+              `query result exceeds ${data.limits.maxResultBytes} byte limit`
+            );
           }
+          resultBytes += rowBytes;
+          resultRows++;
+          rows.push(row);
         }
+        results.push({ type: "data", columns, rows });
+        if (!isReadOnlyStatement(stmt)) hasModifications = true;
       } catch (e) {
-        const error = e.message;
-        results.push({ type: "error", error });
+        const message = sanitizeHostErrorMessage(e.message);
+        results.push({ type: "error", error: message });
         if (data.options.bail) {
           break;
         }
+      } finally {
+        prepared.free();
       }
     }
     let resultBuffer = null;
     if (hasModifications) {
+      const databaseBytes = databaseByteLength(db);
+      if (databaseBytes > data.limits.maxDatabaseBytes) {
+        throw new Error(
+          `database exceeds ${data.limits.maxDatabaseBytes} byte limit`
+        );
+      }
       resultBuffer = db.export();
     }
     db.close();

package/dist/commands/stat/stat.d.ts

@@ -1,4 +1,4 @@
-import type { Command } from "../../types.js";
-export declare const statCommand: Command;
+import type { RuntimeCommand } from "../../types.js";
+export declare const statCommand: RuntimeCommand;
 import type { CommandFuzzInfo } from "../fuzz-flags-types.js";
 export declare const flagsForFuzzing: CommandFuzzInfo;

package/dist/commands/strings/strings.d.ts

@@ -6,7 +6,7 @@
  * For each FILE, print the printable character sequences that are at least
  * MIN characters long. If no FILE is specified, standard input is read.
  */
-import type { Command } from "../../types.js";
-export declare const strings: Command;
+import type { RuntimeCommand } from "../../types.js";
+export declare const strings: RuntimeCommand;
 import type { CommandFuzzInfo } from "../fuzz-flags-types.js";
 export declare const flagsForFuzzing: CommandFuzzInfo;