chainlesschain 0.162.182 → 0.162.183

package/src/lib/process-execution-broker/index.js

@@ -656,6 +656,9 @@ class ProcessExecutionBroker extends EventEmitter {
         "targetRuntime",
         "contentSnapshotScope",
         "contentSnapshotMechanism",
+        "pluginTreeContentSnapshotScope",
+        "pluginTreeContentSnapshotMechanism",
+        "pluginTreeSnapshotConsistency",
       ]) {
         if (
           plan.runtimeProbe[field] !== undefined &&
@@ -668,7 +671,13 @@ class ProcessExecutionBroker extends EventEmitter {
           );
         }
       }
-      for (const field of ["contentSnapshot", "handleAtomic"]) {
+      for (const field of [
+        "contentSnapshot",
+        "handleAtomic",
+        "pluginTreeContentSnapshot",
+        "pluginTreeSnapshotContractBound",
+        "pluginTreeSnapshotAtomic",
+      ]) {
         if (
           plan.runtimeProbe[field] !== undefined &&
           typeof plan.runtimeProbe[field] !== "boolean"
@@ -679,6 +688,217 @@ class ProcessExecutionBroker extends EventEmitter {
           );
         }
       }
+      for (const field of [
+        "pluginTreeContentSnapshotFiles",
+        "pluginTreeContentSnapshotBytes",
+      ]) {
+        if (
+          plan.runtimeProbe[field] !== undefined &&
+          (!Number.isSafeInteger(plan.runtimeProbe[field]) ||
+            plan.runtimeProbe[field] < 0)
+        ) {
+          throw this._sandboxError(
+            "invalid_sandbox_plan",
+            `Sandbox runtime probe ${field} must be a non-negative safe integer`,
+          );
+        }
+      }
+      if (
+        plan.runtimeProbe.pluginTreeContentSnapshotDigest !== undefined &&
+        (typeof plan.runtimeProbe.pluginTreeContentSnapshotDigest !==
+          "string" ||
+          !/^[a-f0-9]{64}$/.test(
+            plan.runtimeProbe.pluginTreeContentSnapshotDigest,
+          ))
+      ) {
+        throw this._sandboxError(
+          "invalid_sandbox_plan",
+          "Sandbox runtime probe pluginTreeContentSnapshotDigest must be a lowercase SHA-256 value",
+        );
+      }
+      const pluginTreeSnapshot =
+        plan.runtimeProbe.pluginTreeContentSnapshot === true;
+      const pluginTreeEvidenceFields = [
+        "pluginTreeContentSnapshotScope",
+        "pluginTreeContentSnapshotMechanism",
+        "pluginTreeContentSnapshotFiles",
+        "pluginTreeContentSnapshotBytes",
+        "pluginTreeContentSnapshotDigest",
+        "pluginTreeSnapshotConsistency",
+        "pluginTreeSnapshotContractBound",
+        "pluginTreeSnapshotAtomic",
+      ];
+      if (
+        pluginTreeSnapshot &&
+        (plan.applied !== true ||
+          plan.platform !== "linux" ||
+          plan.enforcement !== "linux-bwrap" ||
+          backend !== "linux-bwrap" ||
+          candidateBackend !== null ||
+          policyAttested !== true ||
+          policyDigest === null ||
+          !guarantees.includes(SANDBOX_BOUNDARIES.FILESYSTEM) ||
+          !guarantees.includes(SANDBOX_BOUNDARIES.NETWORK) ||
+          plan.runtimeProbe.attempted !== true ||
+          plan.runtimeProbe.runnable !== true ||
+          plan.runtimeProbe.reason !== null ||
+          plan.runtimeProbe.kind !== "linux-bwrap-plugin-node-policy-v1" ||
+          plan.runtimeProbe.probeRuntime !== "node" ||
+          plan.runtimeProbe.targetRuntime !== "node" ||
+          plan.runtimeProbe.contentSnapshot !== true ||
+          plan.runtimeProbe.contentSnapshotScope !== "plugin-entry-source" ||
+          plan.runtimeProbe.contentSnapshotMechanism !==
+            "verified-o_tmpfile-copy-bwrap-ro-bind-data-v1" ||
+          plan.runtimeProbe.handleAtomic !== false ||
+          plan.runtimeProbe.supervisorDescriptorBound !== true ||
+          plan.runtimeProbe.pluginTreeContentSnapshotScope !==
+            "all-pinned-plugin-regular-files" ||
+          plan.runtimeProbe.pluginTreeContentSnapshotMechanism !==
+            "verified-o_tmpfile-copy-bwrap-ro-bind-data-v1" ||
+          !Number.isSafeInteger(
+            plan.runtimeProbe.pluginTreeContentSnapshotFiles,
+          ) ||
+          plan.runtimeProbe.pluginTreeContentSnapshotFiles < 1 ||
+          plan.runtimeProbe.pluginTreeContentSnapshotFiles > 256 ||
+          !Number.isSafeInteger(
+            plan.runtimeProbe.pluginTreeContentSnapshotBytes,
+          ) ||
+          plan.runtimeProbe.pluginTreeContentSnapshotBytes < 0 ||
+          plan.runtimeProbe.pluginTreeContentSnapshotBytes >
+            256 * 1024 * 1024 ||
+          !/^[a-f0-9]{64}$/.test(
+            plan.runtimeProbe.pluginTreeContentSnapshotDigest || "",
+          ) ||
+          plan.runtimeProbe.pluginTreeSnapshotConsistency !==
+            "per-file-pin-to-launch" ||
+          plan.runtimeProbe.pluginTreeSnapshotContractBound !== false ||
+          plan.runtimeProbe.pluginTreeSnapshotAtomic !== false)
+      ) {
+        throw this._sandboxError(
+          "invalid_sandbox_plan",
+          "Sandbox runtime probe plugin tree snapshot evidence must use the typed complete-tree contract",
+        );
+      }
+      if (
+        !pluginTreeSnapshot &&
+        pluginTreeEvidenceFields.some(
+          (field) => plan.runtimeProbe[field] !== undefined,
+        )
+      ) {
+        throw this._sandboxError(
+          "invalid_sandbox_plan",
+          "Sandbox runtime probe plugin tree snapshot evidence requires pluginTreeContentSnapshot",
+        );
+      }
+      const supervisorStringFields = [
+        "supervisorBindingScope",
+        "supervisorDescriptorBindingMechanism",
+        "supervisorPid1ExecutableExposure",
+      ];
+      const supervisorBooleanFields = [
+        "supervisorDescriptorBound",
+        "supervisorExecutablePinned",
+        "supervisorDescriptorContained",
+        "supervisorDescriptorConsumedBeforeTarget",
+        "supervisorStagingPathHidden",
+        "supervisorTemporaryCopyObscured",
+      ];
+      for (const field of supervisorStringFields) {
+        if (
+          plan.runtimeProbe[field] !== undefined &&
+          (typeof plan.runtimeProbe[field] !== "string" ||
+            !plan.runtimeProbe[field])
+        ) {
+          throw this._sandboxError(
+            "invalid_sandbox_plan",
+            `Sandbox runtime probe ${field} must be a non-empty string`,
+          );
+        }
+      }
+      for (const field of supervisorBooleanFields) {
+        if (
+          plan.runtimeProbe[field] !== undefined &&
+          typeof plan.runtimeProbe[field] !== "boolean"
+        ) {
+          throw this._sandboxError(
+            "invalid_sandbox_plan",
+            `Sandbox runtime probe ${field} must be boolean`,
+          );
+        }
+      }
+      const supervisorIdentity = plan.runtimeProbe.supervisorExecutableIdentity;
+      if (supervisorIdentity !== undefined) {
+        const fileId = supervisorIdentity?.fileId;
+        if (
+          !supervisorIdentity ||
+          typeof supervisorIdentity !== "object" ||
+          Array.isArray(supervisorIdentity) ||
+          typeof supervisorIdentity.path !== "string" ||
+          !supervisorIdentity.path.startsWith("/") ||
+          !fileId ||
+          typeof fileId !== "object" ||
+          Array.isArray(fileId) ||
+          typeof fileId.dev !== "string" ||
+          !/^\d+$/.test(fileId.dev) ||
+          typeof fileId.ino !== "string" ||
+          !/^\d+$/.test(fileId.ino) ||
+          typeof supervisorIdentity.sha256 !== "string" ||
+          !/^[a-f0-9]{64}$/.test(supervisorIdentity.sha256) ||
+          !Number.isSafeInteger(supervisorIdentity.bytes) ||
+          supervisorIdentity.bytes <= 0 ||
+          supervisorIdentity.bytes > 256 * 1024 * 1024 ||
+          !Number.isFinite(supervisorIdentity.mtimeMs) ||
+          !Number.isSafeInteger(supervisorIdentity.mode) ||
+          supervisorIdentity.mode <= 0 ||
+          (supervisorIdentity.mode & 0o170000) !== 0o100000 ||
+          (supervisorIdentity.mode & 0o111) === 0 ||
+          (supervisorIdentity.mode & 0o022) !== 0 ||
+          !Number.isSafeInteger(supervisorIdentity.uid) ||
+          supervisorIdentity.uid !== 0 ||
+          !Number.isSafeInteger(supervisorIdentity.gid) ||
+          supervisorIdentity.gid < 0
+        ) {
+          throw this._sandboxError(
+            "invalid_sandbox_plan",
+            "Sandbox runtime probe supervisorExecutableIdentity must use the typed executable identity contract",
+          );
+        }
+      }
+      const supervisorBound =
+        plan.runtimeProbe.supervisorDescriptorBound === true;
+      if (
+        supervisorBound &&
+        (plan.runtimeProbe.supervisorExecutablePinned !== true ||
+          supervisorIdentity === undefined ||
+          plan.runtimeProbe.supervisorBindingScope !==
+            "host-path-replacement" ||
+          plan.runtimeProbe.supervisorDescriptorBindingMechanism !==
+            "pinned-child-fd3-file-consume-run-overmount-v1" ||
+          plan.runtimeProbe.supervisorPid1ExecutableExposure !== "procfs")
+      ) {
+        throw this._sandboxError(
+          "invalid_sandbox_plan",
+          "Sandbox runtime probe bound supervisor evidence must include its typed identity and binding contract",
+        );
+      }
+      for (const field of [
+        "supervisorDescriptorContained",
+        "supervisorDescriptorConsumedBeforeTarget",
+        "supervisorStagingPathHidden",
+        "supervisorTemporaryCopyObscured",
+      ]) {
+        if (
+          (plan.runtimeProbe[field] === true &&
+            (!supervisorBound || plan.runtimeProbe.runnable !== true)) ||
+          (supervisorBound &&
+            plan.runtimeProbe[field] !== plan.runtimeProbe.runnable)
+        ) {
+          throw this._sandboxError(
+            "invalid_sandbox_plan",
+            `Sandbox runtime probe ${field} requires a runnable bound supervisor`,
+          );
+        }
+      }
       runtimeProbe = {
         kind: plan.runtimeProbe.kind,
         attempted: plan.runtimeProbe.attempted,
@@ -708,6 +928,37 @@ class ProcessExecutionBroker extends EventEmitter {
             }
           : {}),
       };
+      for (const field of [
+        "pluginTreeContentSnapshot",
+        ...pluginTreeEvidenceFields,
+      ]) {
+        if (plan.runtimeProbe[field] !== undefined) {
+          runtimeProbe[field] = plan.runtimeProbe[field];
+        }
+      }
+      for (const field of [
+        ...supervisorStringFields,
+        ...supervisorBooleanFields,
+      ]) {
+        if (plan.runtimeProbe[field] !== undefined) {
+          runtimeProbe[field] = plan.runtimeProbe[field];
+        }
+      }
+      if (supervisorIdentity !== undefined) {
+        runtimeProbe.supervisorExecutableIdentity = {
+          path: supervisorIdentity.path,
+          fileId: {
+            dev: supervisorIdentity.fileId.dev,
+            ino: supervisorIdentity.fileId.ino,
+          },
+          sha256: supervisorIdentity.sha256,
+          bytes: supervisorIdentity.bytes,
+          mtimeMs: supervisorIdentity.mtimeMs,
+          mode: supervisorIdentity.mode,
+          uid: supervisorIdentity.uid,
+          gid: supervisorIdentity.gid,
+        };
+      }
     }
     const postSpawn = plan.postSpawn || { required: false, mode: "none" };
     if (