@hachej/boring-sandbox 0.1.83 → 0.1.85

package/dist/providers/runsc/index.d.ts

@@ -1,4 +1,6 @@
 import { z } from 'zod';
+import { d as RuntimeIsolationEvidenceV1, b as RuntimeIsolationDigest, e as RuntimeIsolationEvidenceVerification } from '../../runtimeIsolation-Bn8t1ADl.js';
+export { R as RUNTIME_ISOLATION_ERROR_CODES, a as RUNTIME_ISOLATION_PROBE_IDS, c as RuntimeIsolationErrorCode, f as RuntimeIsolationProbeId, g as RuntimeIsolationProfileV1 } from '../../runtimeIsolation-Bn8t1ADl.js';
 
 declare const RunscPreflightConfigSchema: z.ZodEffects<z.ZodObject<{
     stateRoot: z.ZodEffects<z.ZodString, string, string>;
@@ -213,4 +215,13 @@ interface RunscHostCommandRunner {
 }
 declare function preflightRunsc(input: unknown, runner: RunscHostCommandRunner): Promise<RunscPreflightResult>;
 
-export { RUNSC_PREFLIGHT_ERROR_CODES, RUNSC_REQUIRED_BLOCKED_CIDRS, RUNSC_UNPROVEN_SECURITY_FACTS, type RunscHostCommand, type RunscHostCommandResult, type RunscHostCommandRunner, type RunscPreflightConfig, RunscPreflightError, type RunscPreflightErrorCode, type RunscPreflightErrorRecord, type RunscPreflightResult, type RunscStructuralObservations, type RunscUnprovenSecurityFacts, preflightRunsc, validateRunscPreflightConfig };
+declare function digestRuntimeIsolationValue(value: unknown): RuntimeIsolationDigest;
+declare function createRuntimeIsolationEvidence(input: {
+    profile: unknown;
+    testSuiteDigest: unknown;
+    probes: unknown;
+    positiveControls: unknown;
+}): RuntimeIsolationEvidenceV1;
+declare function verifyRuntimeIsolationEvidence(value: unknown, observedProfile: unknown, observedTestSuiteDigest: unknown): RuntimeIsolationEvidenceVerification;
+
+export { RUNSC_PREFLIGHT_ERROR_CODES, RUNSC_REQUIRED_BLOCKED_CIDRS, RUNSC_UNPROVEN_SECURITY_FACTS, type RunscHostCommand, type RunscHostCommandResult, type RunscHostCommandRunner, type RunscPreflightConfig, RunscPreflightError, type RunscPreflightErrorCode, type RunscPreflightErrorRecord, type RunscPreflightResult, type RunscStructuralObservations, type RunscUnprovenSecurityFacts, RuntimeIsolationDigest, RuntimeIsolationEvidenceV1, RuntimeIsolationEvidenceVerification, createRuntimeIsolationEvidence, digestRuntimeIsolationValue, preflightRunsc, validateRunscPreflightConfig, verifyRuntimeIsolationEvidence };

package/dist/providers/runsc/index.js

@@ -270,11 +270,206 @@ function normalizeError(error) {
   if (error instanceof RunscPreflightError) return error;
   return new RunscPreflightError(RUNSC_PREFLIGHT_ERROR_CODES.commandFailed, "runsc preflight failed");
 }
+
+// src/shared/runtimeIsolation.ts
+var RUNTIME_ISOLATION_PROBE_IDS = [
+  "sibling-filesystem-traversal",
+  "proc-pid-enumeration",
+  "cross-sandbox-signal",
+  "cross-sandbox-ptrace",
+  "mount-access",
+  "device-access",
+  "process-escape",
+  "cross-workspace-network",
+  "secret-access",
+  "resource-ceilings",
+  "teardown"
+];
+var RUNTIME_ISOLATION_ERROR_CODES = {
+  invalidInput: "RUNSC_ISOLATION_INVALID_INPUT",
+  probeFailed: "RUNSC_ISOLATION_PROBE_FAILED",
+  evidenceInvalid: "RUNSC_ISOLATION_EVIDENCE_INVALID",
+  profileDrift: "RUNSC_ISOLATION_PROFILE_DRIFT"
+};
+
+// src/providers/runsc/isolationEvidence.ts
+import { createHash } from "crypto";
+var DIGEST = /^sha256:[a-f0-9]{64}$/;
+var SAFE_FACT = /^[a-zA-Z0-9][a-zA-Z0-9._+ -]{0,127}$/;
+var PROFILE_KEYS = [
+  "schemaVersion",
+  "provider",
+  "kernelRelease",
+  "runtimeVersion",
+  "runtimeBinaryDigest",
+  "rootfsBinaryDigest",
+  "platformMode",
+  "privilegeModel",
+  "containerCapabilities",
+  "workloadIdentity",
+  "networkPolicy",
+  "cgroupPolicy",
+  "providerConfigDigest",
+  "hostPolicyDigest"
+];
+function digestRuntimeIsolationValue(value) {
+  return `sha256:${createHash("sha256").update(canonicalJson(value)).digest("hex")}`;
+}
+function createRuntimeIsolationEvidence(input) {
+  const profile = parseProfile(input.profile);
+  const testSuiteDigest = parseDigest(input.testSuiteDigest);
+  const probes = parseProbes(input.probes);
+  const positiveControls = parsePositiveControls(input.positiveControls);
+  const withoutDigest = {
+    schemaVersion: 1,
+    domain: "boring-runtime-isolation-evidence:v1",
+    profile,
+    profileDigest: digestRuntimeIsolationValue(profile),
+    testSuiteDigest,
+    probes,
+    positiveControls,
+    redaction: {
+      containsHostPaths: false,
+      containsSecrets: false,
+      containsHostPids: false
+    }
+  };
+  return deepFreeze({ ...withoutDigest, evidenceDigest: digestRuntimeIsolationValue(withoutDigest) });
+}
+function verifyRuntimeIsolationEvidence(value, observedProfile, observedTestSuiteDigest) {
+  let evidence;
+  try {
+    evidence = parseEvidence(value);
+  } catch {
+    return rejected(RUNTIME_ISOLATION_ERROR_CODES.evidenceInvalid, "runtime isolation evidence is invalid");
+  }
+  try {
+    const profile = parseProfile(observedProfile);
+    const suiteDigest = parseDigest(observedTestSuiteDigest);
+    if (evidence.testSuiteDigest !== suiteDigest || evidence.profileDigest !== digestRuntimeIsolationValue(profile)) {
+      return rejected(RUNTIME_ISOLATION_ERROR_CODES.profileDrift, "runtime isolation qualification drifted");
+    }
+    if (canonicalJson(evidence.profile) !== canonicalJson(profile)) {
+      return rejected(RUNTIME_ISOLATION_ERROR_CODES.profileDrift, "runtime isolation qualification drifted");
+    }
+    const { evidenceDigest, ...withoutDigest } = evidence;
+    if (evidenceDigest !== digestRuntimeIsolationValue(withoutDigest)) {
+      return rejected(RUNTIME_ISOLATION_ERROR_CODES.evidenceInvalid, "runtime isolation evidence digest is invalid");
+    }
+    return { status: "accepted", evidenceDigest };
+  } catch {
+    return rejected(RUNTIME_ISOLATION_ERROR_CODES.profileDrift, "runtime isolation qualification drifted");
+  }
+}
+function parseEvidence(value) {
+  const record = strictRecord(value, [
+    "schemaVersion",
+    "domain",
+    "profile",
+    "profileDigest",
+    "testSuiteDigest",
+    "probes",
+    "positiveControls",
+    "redaction",
+    "evidenceDigest"
+  ]);
+  if (record.schemaVersion !== 1 || record.domain !== "boring-runtime-isolation-evidence:v1") invalid2();
+  const redaction = strictRecord(record.redaction, ["containsHostPaths", "containsSecrets", "containsHostPids"]);
+  if (redaction.containsHostPaths !== false || redaction.containsSecrets !== false || redaction.containsHostPids !== false) invalid2();
+  return {
+    schemaVersion: 1,
+    domain: "boring-runtime-isolation-evidence:v1",
+    profile: parseProfile(record.profile),
+    profileDigest: parseDigest(record.profileDigest),
+    testSuiteDigest: parseDigest(record.testSuiteDigest),
+    probes: parseProbes(record.probes),
+    positiveControls: parsePositiveControls(record.positiveControls),
+    redaction: { containsHostPaths: false, containsSecrets: false, containsHostPids: false },
+    evidenceDigest: parseDigest(record.evidenceDigest)
+  };
+}
+function parseProfile(value) {
+  const p = strictRecord(value, PROFILE_KEYS);
+  const limits = strictRecord(p.cgroupPolicy, ["version", "cpuQuotaMicros", "cpuPeriodMicros", "memoryBytes", "pidsMax"]);
+  if (p.schemaVersion !== 1 || p.provider !== "runsc" || p.platformMode !== "systrap" || p.privilegeModel !== "sudo-root" || p.workloadIdentity !== "uid-65532-gid-65532" || p.networkPolicy !== "isolated-veth-no-default-route" || limits.version !== 2 || limits.cpuQuotaMicros !== 5e4 || limits.cpuPeriodMicros !== 1e5 || limits.memoryBytes !== 134217728 || limits.pidsMax !== 64 || !Array.isArray(p.containerCapabilities) || p.containerCapabilities.length !== 0) invalid2();
+  for (const fact of [p.kernelRelease, p.runtimeVersion]) {
+    if (typeof fact !== "string" || !SAFE_FACT.test(fact)) invalid2();
+  }
+  return deepFreeze({
+    schemaVersion: 1,
+    provider: "runsc",
+    kernelRelease: p.kernelRelease,
+    runtimeVersion: p.runtimeVersion,
+    runtimeBinaryDigest: parseDigest(p.runtimeBinaryDigest),
+    rootfsBinaryDigest: parseDigest(p.rootfsBinaryDigest),
+    platformMode: "systrap",
+    privilegeModel: "sudo-root",
+    containerCapabilities: [],
+    workloadIdentity: "uid-65532-gid-65532",
+    networkPolicy: "isolated-veth-no-default-route",
+    cgroupPolicy: { version: 2, cpuQuotaMicros: 5e4, cpuPeriodMicros: 1e5, memoryBytes: 134217728, pidsMax: 64 },
+    providerConfigDigest: parseDigest(p.providerConfigDigest),
+    hostPolicyDigest: parseDigest(p.hostPolicyDigest)
+  });
+}
+function parseProbes(value) {
+  const p = strictRecord(value, RUNTIME_ISOLATION_PROBE_IDS);
+  for (const id of RUNTIME_ISOLATION_PROBE_IDS) if (p[id] !== "passed") invalid2();
+  return deepFreeze(Object.fromEntries(RUNTIME_ISOLATION_PROBE_IDS.map((id) => [id, "passed"])));
+}
+function parsePositiveControls(value) {
+  const keys = [
+    "ownMarkerReadable",
+    "attackerEndpointReachableBeforeHostileCalls",
+    "attackerEndpointReachableAfterHostileCalls",
+    "siblingEndpointReachableFromSibling",
+    "siblingCanaryReadableFromSibling",
+    "siblingAliveBeforeHostileCalls",
+    "siblingAliveAfterHostileCalls"
+  ];
+  const controls = strictRecord(value, keys);
+  for (const key of keys) if (controls[key] !== true) invalid2();
+  return deepFreeze(Object.fromEntries(keys.map((key) => [key, true])));
+}
+function strictRecord(value, keys) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) invalid2();
+  const record = value;
+  const actual = Object.keys(record);
+  if (actual.length !== keys.length || actual.some((key) => !keys.includes(key))) invalid2();
+  return record;
+}
+function parseDigest(value) {
+  if (typeof value !== "string" || !DIGEST.test(value)) invalid2();
+  return value;
+}
+function canonicalJson(value) {
+  if (value === null || typeof value !== "object") return JSON.stringify(value);
+  if (Array.isArray(value)) return `[${value.map(canonicalJson).join(",")}]`;
+  return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${canonicalJson(value[key])}`).join(",")}}`;
+}
+function deepFreeze(value) {
+  if (typeof value === "object" && value !== null) {
+    for (const child of Object.values(value)) deepFreeze(child);
+    Object.freeze(value);
+  }
+  return value;
+}
+function invalid2() {
+  throw new Error("invalid runtime isolation evidence");
+}
+function rejected(code, message) {
+  return { status: "rejected", code, message };
+}
 export {
   RUNSC_PREFLIGHT_ERROR_CODES,
   RUNSC_REQUIRED_BLOCKED_CIDRS,
   RUNSC_UNPROVEN_SECURITY_FACTS,
+  RUNTIME_ISOLATION_ERROR_CODES,
+  RUNTIME_ISOLATION_PROBE_IDS,
   RunscPreflightError,
+  createRuntimeIsolationEvidence,
+  digestRuntimeIsolationValue,
   preflightRunsc,
-  validateRunscPreflightConfig
+  validateRunscPreflightConfig,
+  verifyRuntimeIsolationEvidence
 };

package/dist/runtimeIsolation-Bn8t1ADl.d.ts

@@ -0,0 +1,65 @@
+declare const RUNTIME_ISOLATION_PROBE_IDS: readonly ["sibling-filesystem-traversal", "proc-pid-enumeration", "cross-sandbox-signal", "cross-sandbox-ptrace", "mount-access", "device-access", "process-escape", "cross-workspace-network", "secret-access", "resource-ceilings", "teardown"];
+type RuntimeIsolationProbeId = (typeof RUNTIME_ISOLATION_PROBE_IDS)[number];
+type RuntimeIsolationDigest = `sha256:${string}`;
+declare const RUNTIME_ISOLATION_ERROR_CODES: {
+    readonly invalidInput: "RUNSC_ISOLATION_INVALID_INPUT";
+    readonly probeFailed: "RUNSC_ISOLATION_PROBE_FAILED";
+    readonly evidenceInvalid: "RUNSC_ISOLATION_EVIDENCE_INVALID";
+    readonly profileDrift: "RUNSC_ISOLATION_PROFILE_DRIFT";
+};
+type RuntimeIsolationErrorCode = (typeof RUNTIME_ISOLATION_ERROR_CODES)[keyof typeof RUNTIME_ISOLATION_ERROR_CODES];
+interface RuntimeIsolationProfileV1 {
+    readonly schemaVersion: 1;
+    readonly provider: "runsc";
+    readonly kernelRelease: string;
+    readonly runtimeVersion: string;
+    readonly runtimeBinaryDigest: RuntimeIsolationDigest;
+    readonly rootfsBinaryDigest: RuntimeIsolationDigest;
+    readonly platformMode: "systrap";
+    readonly privilegeModel: "sudo-root";
+    readonly containerCapabilities: readonly [];
+    readonly workloadIdentity: "uid-65532-gid-65532";
+    readonly networkPolicy: "isolated-veth-no-default-route";
+    readonly cgroupPolicy: {
+        readonly version: 2;
+        readonly cpuQuotaMicros: 50_000;
+        readonly cpuPeriodMicros: 100_000;
+        readonly memoryBytes: 134_217_728;
+        readonly pidsMax: 64;
+    };
+    readonly providerConfigDigest: RuntimeIsolationDigest;
+    readonly hostPolicyDigest: RuntimeIsolationDigest;
+}
+interface RuntimeIsolationEvidenceV1 {
+    readonly schemaVersion: 1;
+    readonly domain: "boring-runtime-isolation-evidence:v1";
+    readonly profile: RuntimeIsolationProfileV1;
+    readonly profileDigest: RuntimeIsolationDigest;
+    readonly testSuiteDigest: RuntimeIsolationDigest;
+    readonly probes: Readonly<Record<RuntimeIsolationProbeId, "passed">>;
+    readonly positiveControls: {
+        readonly ownMarkerReadable: true;
+        readonly attackerEndpointReachableBeforeHostileCalls: true;
+        readonly attackerEndpointReachableAfterHostileCalls: true;
+        readonly siblingEndpointReachableFromSibling: true;
+        readonly siblingCanaryReadableFromSibling: true;
+        readonly siblingAliveBeforeHostileCalls: true;
+        readonly siblingAliveAfterHostileCalls: true;
+    };
+    readonly redaction: {
+        readonly containsHostPaths: false;
+        readonly containsSecrets: false;
+        readonly containsHostPids: false;
+    };
+    readonly evidenceDigest: RuntimeIsolationDigest;
+}
+type RuntimeIsolationEvidenceVerification = {
+    readonly status: "accepted";
+    readonly evidenceDigest: RuntimeIsolationDigest;
+} | {
+    readonly status: "rejected";
+    readonly code: RuntimeIsolationErrorCode;
+    readonly message: string;
+};
+
+export { RUNTIME_ISOLATION_ERROR_CODES as R, RUNTIME_ISOLATION_PROBE_IDS as a, type RuntimeIsolationDigest as b, type RuntimeIsolationErrorCode as c, type RuntimeIsolationEvidenceV1 as d, type RuntimeIsolationEvidenceVerification as e, type RuntimeIsolationProbeId as f, type RuntimeIsolationProfileV1 as g };

package/dist/shared/index.d.ts

@@ -1,3 +1,5 @@
+export { R as RUNTIME_ISOLATION_ERROR_CODES, a as RUNTIME_ISOLATION_PROBE_IDS, b as RuntimeIsolationDigest, c as RuntimeIsolationErrorCode, d as RuntimeIsolationEvidenceV1, e as RuntimeIsolationEvidenceVerification, f as RuntimeIsolationProbeId, g as RuntimeIsolationProfileV1 } from '../runtimeIsolation-Bn8t1ADl.js';
+
 type ProviderFilesystemCapability = "none" | "readonly" | "readwrite";
 type ProviderNetworkIsolation = "none" | "process" | "container" | "microvm" | "provider";
 type ProviderSourceOfTruth = "sandbox-primary" | "storage-primary";

package/dist/shared/index.js

@@ -105,9 +105,32 @@ var MODE_TO_PROVIDER = {
   "vercel-sandbox": "vercel-sandbox",
   "remote-worker": "remote-worker"
 };
+
+// src/shared/runtimeIsolation.ts
+var RUNTIME_ISOLATION_PROBE_IDS = [
+  "sibling-filesystem-traversal",
+  "proc-pid-enumeration",
+  "cross-sandbox-signal",
+  "cross-sandbox-ptrace",
+  "mount-access",
+  "device-access",
+  "process-escape",
+  "cross-workspace-network",
+  "secret-access",
+  "resource-ceilings",
+  "teardown"
+];
+var RUNTIME_ISOLATION_ERROR_CODES = {
+  invalidInput: "RUNSC_ISOLATION_INVALID_INPUT",
+  probeFailed: "RUNSC_ISOLATION_PROBE_FAILED",
+  evidenceInvalid: "RUNSC_ISOLATION_EVIDENCE_INVALID",
+  profileDrift: "RUNSC_ISOLATION_PROFILE_DRIFT"
+};
 export {
   MODE_TO_PROVIDER,
   PROVIDER_CAPABILITIES,
   PROVIDER_CAPABILITY_ERROR_CODES,
-  PROVIDER_CONTRACT_VERSION
+  PROVIDER_CONTRACT_VERSION,
+  RUNTIME_ISOLATION_ERROR_CODES,
+  RUNTIME_ISOLATION_PROBE_IDS
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hachej/boring-sandbox",
-  "version": "0.1.83",
+  "version": "0.1.85",
   "type": "module",
   "license": "MIT",
   "description": "Sandbox provider contracts and implementations for Boring runtimes.",
@@ -44,6 +44,7 @@
     "typecheck": "tsc --noEmit",
     "check:invariants": "node ./scripts/check-invariants.mjs",
     "lint": "pnpm run typecheck && pnpm run check:invariants",
+    "qualify:runsc:isolation": "node ./scripts/qualify-runsc-isolation.mjs",
     "test": "vitest run --passWithNoTests",
     "clean": "rm -rf dist .tsbuildinfo"
   }