@ai-ecoverse/slicc-kernel 1.136.2 → 1.136.4

package/README.md

@@ -327,7 +327,7 @@ On top of preview1 a WASI program gets:
   A kernel without the imports answers `ENOSYS`, and the libc reports `SI_USER` with pid and uid 0, as before. **SIGCHLD:** with `SIGCHLD` set to `SIG_IGN` (by the program, or inherited), or with `SA_NOCLDWAIT` in the flags `slicc.sigaction_set` gets for `SIGCHLD`, an exited child is reaped at once and never stays a zombie: `waitpid` for it is `ECHILD`, and `wait` blocks until every child has exited, then fails with `ECHILD`, as on Linux. `SIGCHLD` is still sent. An explicit `SIG_DFL` turns it back off. A child that a process waits on for `exec`, or that `kernel.run` and the run calls collect, is never reaped that way.
 - **Pipes** have no file type for WASI and WASIX programs' `fstat` (`st_mode` type 0), because WASI has no FIFO file type. A socket type, as kernels 1.47.3 to 1.48.1 gave them, made Ruby treat a `popen` pipe as a socket (`close_write` then never ends the child's input). The kernel's `slicc_fs.fd_mode` answers `S_IFIFO | 0600` (Linux numbering) for a pipe, and wasix-sysroot 2025.9.30-21 and later take the type from it, so programs built on it see a FIFO (`S_ISFIFO`); older libcs keep only the permission bits. Until then Python's asyncio refuses a pipe for a subprocess (`Pipe transport is only for pipes, sockets and character devices`). They are read and written as pipes; socket calls on them fail with `ENOTSOCK`, and `isatty()` is false. Emscripten programs, bash included, see a FIFO. The same holds for any kernel descriptor that is neither seekable nor a terminal or device, such as captured output.
 - **Sockets**: the WASIX socket calls (`sock_open`, `sock_pair` for an `AF_UNIX` stream or datagram pair, `bind`, `listen`, `connect`, `accept`, options, local and peer names) are the kernel's loopback sockets, and preview1's `sock_recv` / `sock_send` / `sock_shutdown` work on them and on inherited ones. Writing to a socket whose peer is gone fails with `EPIPE`, through `fd_write` as through `sock_send`, as if `MSG_NOSIGNAL` were set. A write to a pipe, FIFO or terminal whose reader is gone follows the program's `SIGPIPE` disposition, as the kernel knows it (#810): at the default it ends the program with status 141; ignored (also an ignore inherited across `exec` and spawn, as bash's `trap '' PIPE` passes on), the write fails with `EPIPE`; with a handler, the handler runs on the thread that wrote and then the write fails with `EPIPE` (#820); blocked, `SIGPIPE` stays pending and the write fails with `EPIPE`. An Emscripten program's write to a pipe, and its `send` without `MSG_NOSIGNAL`, follow the same rules, except that the kernel doesn't see an Emscripten program's signal mask, so a blocked `SIGPIPE` there still ends it. A WASIX program's libc reads an inherited ignore back through `slicc.sigaction_inherited` (wasix-sysroot -32 and later; see below). An Emscripten program's shim reads it from `Module.sliccKernel.sigInherited()` (#965, homescoop#973). That's a mask with bit n set for signal n (not bit n-1, as the WASIX import has it) holding only inherited `SIG_IGN`s, never `SIGKILL` or `SIGSTOP`. The shim seeds its `sigaction` table from it in a constructor that runs before any user constructor. The kernel puts the function on `Module.sliccKernel` before the glue runs constructors, ahead of the rest of `sliccKernel`. On a kernel without the function it is undefined, and the shim keeps the defaults. HTTP and HTTPS leave through the realm proxy that `https_proxy` names, as for any other program; `resolve` answers `/etc/hosts` names and literal addresses, and the [uplink](#uplink)'s names. `sock_open(SOCK_DGRAM)` on `AF_INET`/`AF_INET6` gives a [datagram socket](#datagram-sockets-udp); `sock_send_to` and `sock_recv_from` carry its addresses, and `RECV_DATA_TRUNCATED` is set in `ro_flags` when a datagram did not fit.
-- **Diagnostics**: a trap ends the program with 134 and its message on stderr; with `SLICC_WASM_BACKTRACE=1` the wasm frames follow, named from the module's name section, or from a sidecar for a module shipped without one (`<module>.names` beside it, or the same path in a `<package>-names` package). `SLICC_WASI_STATS=1` makes a program print its calls, counted and timed, as it ends.
+- **Diagnostics**: a trap ends the program with 134 and its message on stderr; a program that crashes its worker otherwise (a JS stack overflow, `RangeError: Maximum call stack size exceeded`, or any other uncaught error) ends with 70, and its message goes to the process's own fd 2 too, so `2>` catches it (#1237), or to the session's stderr when it has no fd 2 to write; with `SLICC_WASM_BACKTRACE=1` the wasm frames follow, named from the module's name section, or from a sidecar for a module shipped without one (`<module>.names` beside it, or the same path in a `<package>-names` package). `SLICC_WASI_STATS=1` makes a program print its calls, counted and timed, as it ends.
 
 ### Program imports
 
@@ -505,10 +505,20 @@ The module's default export (or its `main` export) is called with a context and
         - `AUTH LOGIN`: the password line (the second line, or the first after `AUTH LOGIN <user>`) is decoded, substituted (`auth-login`) and re-encoded; the user line goes out as written.
         - Every other line goes out as written. After the first `AUTH`, or once `MAIL`, `RCPT`, `DATA` or `BDAT` is seen, so is the rest of the session. A line still unfinished after 2 s, or longer than 4 KiB, is sent as written, and so is the rest.
       - **pg:** a session that starts with a protocol 3 `StartupMessage` (after `sslmode`'s `SSLRequest` upgrade, or with direct TLS) is followed message by message. The only position is the **`PasswordMessage` answering `AuthenticationCleartextPassword` (`R` 3)**, as the program read it from the server. The password is substituted (`password-cleartext`) and the message is framed again. **SCRAM-SHA-256** (`R` 10, the pg 14+ default) works with an unmodified client:
-        - **What the server is offered:** in a session that can substitute, the kernel offers the program only `SCRAM-SHA-256`, never `-PLUS`. The program's client computes its proof from the placeholder. Dropping `-PLUS` costs nothing here: the kernel terminates and verifies the TLS itself, so channel binding would only bind to the kernel's own session. A client that **requires** channel binding (libpq's `channel_binding=require`) refuses the connection and never gets the value, so leave it at `prefer` or `disable` for sealed SCRAM.
+        - **What the program is offered:** the server's mechanisms. `SCRAM-SHA-256-PLUS` is offered only when the kernel can bind to the server: a verified session whose leaf certificate's signature hash is SHA-256, SHA-384 or SHA-512, with MD5 and SHA-1 counting as SHA-256 (RFC 5929 §4.1). With any other hash (RSA-PSS or Ed25519, say), `-PLUS` is dropped. So libpq's default `channel_binding=prefer`, `require`, and node-postgres' `enableChannelBinding` all work.
+        - **Channel binding (`tls-server-end-point`):** the kernel changes only what the server would refuse.
+          - `n,,` goes out as written.
+          - `y,,` goes out as written to a server that didn't offer `-PLUS`. Otherwise it becomes `SCRAM-SHA-256-PLUS` with `p=tls-server-end-point,,` (or `n,,` when the kernel can't bind), because pg refuses `y,,` from a client after offering `-PLUS`.
+          - `p=tls-server-end-point,,` keeps its header. Its `c=` binding data becomes the hash of the leaf the kernel verified, when the program's differs.
+          - Any other `p=` type is changed to the kernel's choice.
+
+          So a program that asks for binding is bound to the real server. A program using its own password in such a session still authenticates whenever nothing had to change: `n,,`, `y,,` without `-PLUS`, or a right `p=`.
+        - **The vault:** substitution with `-PLUS` (a program's `p=tls-server-end-point`) needs slicc-vault ≥ 1.15.1. An older vault refuses `p=` with `EINVAL` and fails closed. A program's `p=tls-unique` or `p=tls-exporter` fails in a substituting session either way: the vault refuses it with a placeholder (`EINVAL`), and with the program's own password, the kernel's rewrite to `tls-server-end-point` invalidates its proof. PostgreSQL supports only `tls-server-end-point` anyway.
+        - **Two auth messages:** the vault and the check against the placeholder see the program's own messages (P). The server sees the kernel's (S), with its header and `c=`. The real proof is computed over S, and the server's signature is verified over S before the program gets the placeholder's signature over P.
         - **The match:** the kernel sends the three SCRAM messages and that proof to the vault (`scram-sha-256`, with no placeholders), and the vault names the one bound placeholder whose proof matches.
         - **The exchange:** the kernel recomputes the proof from the value and sends that instead. It checks the server's final signature against the value **before** it hands the program the signature its own placeholder-based check expects. A server whose signature doesn't verify, or that answers with an error, ends the session (`EPROTO`) without passing it on. The salted password and the derived keys are wiped after the exchange.
-        - **Requirements:** only the plain GS2 header (`n,,`) and the bare RFC 5802 messages; at most 100000 iterations.
+        - **Requirements:** a GS2 header without an authorization identity (`n,,`, `y,,` or `p=<type>,,`), whose `c=` starts with it, and the bare RFC 5802 messages; at most 100000 iterations.
+        - **A stale vault value:** on a verified session, a value the server no longer accepts makes its final signature fail to verify. The program sees `EPROTO`, not pg's `28P01`. This is by design: the kernel never passes on a signature it couldn't check.
 
         Anything else goes out as written: the startup, an MD5 (`R` 5) answer, every later message, and a frame over 16 KiB. A server whose `pg_hba` asks for MD5 gets the placeholder, and refuses.
       - **Vault anchors** (§3.19.6) are for private-CA services such as managed pg and corporate APIs.
@@ -1266,6 +1276,16 @@ Not part of the run yet: the rest of bios's setup (the `rest` shard, the upgrade
 
 The WASIX fixtures of `test/integration/epoll.test.mjs` (#674), under `test/integration/fixtures/`, are committed with their sources, build scripts and built wasm.
 
+### `pg-fixture` with `plus`
+
+`test/integration/pg-fixture.mjs`, `pgFixture(t, cert, password, { plus: true })`: pg-gateway's SCRAM-SHA-256 server, which offers `SCRAM-SHA-256-PLUS` too and refuses as PostgreSQL's `auth-scram.c` does (jsh#531):
+- `y,,` after it offered `-PLUS`: "SCRAM channel binding negotiation error";
+- `p=` with `SCRAM-SHA-256`, and `SCRAM-SHA-256-PLUS` without `p=`;
+- a channel-binding type other than `tls-server-end-point`;
+- a `c=` other than base64 of the GS2 header plus, for `-PLUS`, the SHA-256 of its leaf.
+
+The refusals and the client-final messages are recorded in `seen.plus`. The real-server check is slicc-jsh's, against PostgreSQL over SSL.
+
 ### `heldcwd`
 
 `test/integration/fixtures/heldcwd`: a Rust wasm32-wasip1 program, built by `build.sh` with rustup's wasm32-wasip1 target, for the [working directory](#the-working-directory) rows (#1164).

package/dist/kernel-worker.js

@@ -7098,7 +7098,7 @@ function satisfies(version, range2) {
 }
 
 // src/version.ts
-var KERNEL_VERSION = true ? "1.136.2" : "0.0.0-dev";
+var KERNEL_VERSION = true ? "1.136.4" : "0.0.0-dev";
 var OS_RELEASE = "6.0.0-slicc";
 function procVersion() {
   return `Linux version ${OS_RELEASE} (slicc-kernel ${KERNEL_VERSION}) #1 SMP PREEMPT_DYNAMIC
@@ -18560,6 +18560,66 @@ async function anchorFor(engine, chain2, host, found) {
   return void 0;
 }
 
+// src/kernel/net/sealed-binding.ts
+var HASH_OF_SIGNATURE = {
+  "1.2.840.113549.1.1.4": "SHA-256",
+  "1.2.840.113549.1.1.5": "SHA-256",
+  "1.2.840.10045.4.1": "SHA-256",
+  "1.2.840.10040.4.3": "SHA-256",
+  "1.2.840.113549.1.1.11": "SHA-256",
+  "1.2.840.10045.4.3.2": "SHA-256",
+  "1.2.840.113549.1.1.12": "SHA-384",
+  "1.2.840.10045.4.3.3": "SHA-384",
+  "1.2.840.113549.1.1.13": "SHA-512",
+  "1.2.840.10045.4.3.4": "SHA-512"
+};
+function tlv3(der2, at) {
+  const tag = der2[at];
+  let len = der2[at + 1];
+  if (tag === void 0 || len === void 0) return void 0;
+  let start2 = at + 2;
+  if (len & 128) {
+    const n = len & 127;
+    if (n === 0 || n > 4) return void 0;
+    len = 0;
+    for (let i = 0; i < n; i++) len = len * 256 + (der2[start2 + i] ?? 0);
+    start2 += n;
+  }
+  const end = start2 + len;
+  return end <= der2.length ? { tag, start: start2, end } : void 0;
+}
+function oidText(bytes) {
+  const first = bytes[0] ?? 0;
+  const parts2 = [Math.floor(first / 40), first % 40];
+  let value2 = 0;
+  for (const b of bytes.subarray(1)) {
+    value2 = value2 * 128 + (b & 127);
+    if ((b & 128) === 0) {
+      parts2.push(value2);
+      value2 = 0;
+    }
+  }
+  return parts2.join(".");
+}
+function signatureOid(cert) {
+  const outer = tlv3(cert, 0);
+  if (outer?.tag !== 48) return void 0;
+  const tbs = tlv3(cert, outer.start);
+  if (tbs?.tag !== 48) return void 0;
+  const algorithm = tlv3(cert, tbs.end);
+  if (algorithm?.tag !== 48) return void 0;
+  const oid2 = tlv3(cert, algorithm.start);
+  if (oid2?.tag !== 6) return void 0;
+  return oidText(cert.subarray(oid2.start, oid2.end));
+}
+async function endPointBinding(cert) {
+  if (!cert) return void 0;
+  const oid2 = signatureOid(cert);
+  const hash = oid2 === void 0 ? void 0 : HASH_OF_SIGNATURE[oid2];
+  if (!hash) return void 0;
+  return new Uint8Array(await crypto.subtle.digest(hash, cert));
+}
+
 // node_modules/@ai-ecoverse/slicc-scrub/dist/index.js
 var FRAGMENT = 16;
 var MIN_VALUE = 8;
@@ -19295,25 +19355,35 @@ function base64Of(bytes) {
   for (const b of bytes) bin += String.fromCharCode(b);
   return btoa(bin);
 }
-function clientFirstBare(message3) {
-  const m = /^n,,(n=[^,]*,r=[^,]+)$/.exec(message3);
-  return m ? m[1] : void 0;
+function clientFirstOf(message3) {
+  const m = /^((?:n|y|p=[A-Za-z0-9.-]+),,)(n=[^,]*,r=[^,]+)$/.exec(message3);
+  return m ? { header: m[1], bare: m[2] } : void 0;
+}
+var latinBytes = (text) => Uint8Array.from(text, (c) => c.charCodeAt(0));
+function channelOf(header3, binding) {
+  const head = latinBytes(header3);
+  const all = new Uint8Array(head.length + (binding?.length ?? 0));
+  all.set(head);
+  if (binding) all.set(binding, head.length);
+  return base64Of(all);
 }
 var SERVER_FIRST = /^r=([^,]+),s=([^,]+),i=(\d{1,6})$/;
-var CLIENT_FINAL = /^(c=biws,r=([^,]+)),p=([^,]+)$/;
+var CLIENT_FINAL = /^(c=([A-Za-z0-9+/]+={0,2}),r=([^,]+)),p=([^,]+)$/;
 var SCRAM_MAX = 1024;
 function exchangeOf(clientFirst, serverFirst, clientFinal) {
-  const bare = clientFirstBare(clientFirst);
+  const first = clientFirstOf(clientFirst);
+  const bare = first?.bare;
   const sf = SERVER_FIRST.exec(serverFirst);
   const fin = CLIENT_FINAL.exec(clientFinal);
   if (!bare || !sf || !fin || [bare, serverFirst, clientFinal].some((t) => t.length > SCRAM_MAX))
     return void 0;
+  const channel = base64Bytes(fin[2]);
   const cnonce = bare.slice(bare.indexOf(",r=") + 3);
   const nonce = sf[1];
   const salt = base64Bytes(sf[2]);
   const iterations = Number(sf[3]);
-  const proof = base64Bytes(fin[3]);
-  const ok4 = fin[2] === nonce && nonce.startsWith(cnonce) && iterations >= 1 && iterations <= 1e5 && salt !== void 0 && proof?.length === 32;
+  const proof = base64Bytes(fin[4]);
+  const ok4 = channel !== void 0 && latin(channel).startsWith(first.header) && fin[3] === nonce && nonce.startsWith(cnonce) && iterations >= 1 && iterations <= 1e5 && salt !== void 0 && proof?.length === 32;
   if (!ok4) return void 0;
   return {
     exchange: {
@@ -19323,9 +19393,16 @@ function exchangeOf(clientFirst, serverFirst, clientFinal) {
       salt,
       iterations
     },
-    proof
+    proof,
+    channel,
+    nonce
   };
 }
+function latin(bytes) {
+  let out = "";
+  for (const b of bytes) out += String.fromCharCode(b);
+  return out;
+}
 async function hmac(key, data) {
   const k = await crypto.subtle.importKey(
     "raw",
@@ -19392,16 +19469,23 @@ function sniffPg(start2) {
   const length2 = int32(bytes, 0);
   return length2 >= 8 && length2 <= PG_MESSAGE_MAX && int32(bytes, 4) === PROTOCOL_3 ? "yes" : "no";
 }
+var PLAIN = "SCRAM-SHA-256";
 var PLUS = "SCRAM-SHA-256-PLUS";
+var END_POINT = "p=tls-server-end-point,,";
 var SASL = 10;
 var SASL_CONTINUE = 11;
 var SASL_FINAL = 12;
-function latin(bytes) {
+function latin2(bytes) {
   let out = "";
   for (const b of bytes) out += String.fromCharCode(b);
   return out;
 }
 var PgServer = class {
+  binding;
+  plus = false;
+  constructor(binding) {
+    this.binding = binding;
+  }
   buffer = new Uint8Array(0);
   skip = 0;
   cleartext = false;
@@ -19415,20 +19499,22 @@ var PgServer = class {
     if (this.expect && code !== SASL_FINAL) this.failed = true;
     this.cleartext = message3.length === 9 && code === CLEARTEXT;
     if (code === SASL) return this.mechanisms(message3);
-    else if (code === SASL_CONTINUE) this.serverFirst = latin(message3.subarray(9));
+    else if (code === SASL_CONTINUE) this.serverFirst = latin2(message3.subarray(9));
     else if (code === SASL_FINAL) this.final(message3);
     return message3;
   }
   mechanisms(message3) {
     this.sasl = true;
-    const names2 = latin(message3.subarray(9)).split("\0").filter((n) => n !== "" && n !== PLUS);
-    return frame3(82, `${latin(message3.subarray(5, 9))}${names2.map((n) => `${n}\0`).join("")}\0`);
+    const offered = latin2(message3.subarray(9)).split("\0").filter((n) => n !== "");
+    this.plus = offered.includes(PLUS);
+    const names2 = offered.filter((n) => n !== PLUS || this.binding !== void 0);
+    return frame3(82, `${latin2(message3.subarray(5, 9))}${names2.map((n) => `${n}\0`).join("")}\0`);
   }
   final(message3) {
     const expect = this.expect;
     if (!expect) return;
     this.expect = void 0;
-    const data = latin(message3.subarray(9));
+    const data = latin2(message3.subarray(9));
     if (data !== expect.real || expect.fake.length !== expect.real.length) {
       this.failed = true;
       return;
@@ -19503,9 +19589,9 @@ function pgLength(bytes, started) {
   const length2 = int32(bytes, started ? 1 : 0);
   return started ? 1 + length2 : length2;
 }
-var MECHANISMS = /* @__PURE__ */ new Set(["SCRAM-SHA-256"]);
+var MECHANISMS = /* @__PURE__ */ new Set([PLAIN, PLUS]);
 async function cleartext(message3, asks) {
-  const body = latin(message3.subarray(5));
+  const body = latin2(message3.subarray(5));
   if (!body.endsWith("\0") || body.indexOf("\0") !== body.length - 1)
     return { bytes: message3, done: true };
   const password = body.slice(0, -1);
@@ -19517,14 +19603,30 @@ async function cleartext(message3, asks) {
   return { bytes: frame3(112, `${replaced(password, values)}\0`), values, done: true };
 }
 function initial(message3) {
-  const body = latin(message3.subarray(5));
+  const body = latin2(message3.subarray(5));
   const nul = body.indexOf("\0");
-  if (nul < 0 || !MECHANISMS.has(body.slice(0, nul)) || body.length < nul + 5) return void 0;
+  const mechanism = body.slice(0, nul);
+  if (nul < 0 || !MECHANISMS.has(mechanism) || body.length < nul + 5) return void 0;
   const data = message3.subarray(5 + nul + 5);
-  return int32(message3, 5 + nul + 1) === data.length ? latin(data) : void 0;
+  return int32(message3, 5 + nul + 1) === data.length ? { mechanism, data: latin2(data) } : void 0;
+}
+function int32Text(n) {
+  return String.fromCharCode(n >>> 24 & 255, n >>> 16 & 255, n >>> 8 & 255, n & 255);
+}
+function serverHeader(header3, server) {
+  if (header3 === "n,,") return header3;
+  if (header3 === "y,," && !server.plus) return header3;
+  if (header3 === END_POINT && server.binding) return header3;
+  return server.plus && server.binding ? END_POINT : "n,,";
+}
+function rewritten(first, header3) {
+  const parsed2 = clientFirstOf(first.data);
+  if (!parsed2 || parsed2.header === header3) return first;
+  return { mechanism: header3 === END_POINT ? PLUS : PLAIN, data: `${header3}${parsed2.bare}` };
 }
 var PgClient = class {
   clientFirst;
+  header = "n,,";
   server;
   asks;
   constructor(server, asks) {
@@ -19539,17 +19641,28 @@ var PgClient = class {
       return cleartext(message3, this.asks);
     }
     if (server.sasl && this.clientFirst === void 0) {
-      this.clientFirst = initial(message3);
-      return { bytes: message3, done: this.clientFirst === void 0 };
+      const first = initial(message3);
+      const parsed2 = first && clientFirstOf(first.data);
+      if (!first || !parsed2) return { bytes: message3, done: true };
+      this.clientFirst = first.data;
+      this.header = serverHeader(parsed2.header, server);
+      const sent = rewritten(first, this.header);
+      if (sent === first) return { bytes: message3, done: false };
+      return {
+        bytes: frame3(112, `${sent.mechanism}\0${int32Text(sent.data.length)}${sent.data}`),
+        done: false
+      };
     }
     if (this.clientFirst !== void 0 && server.serverFirst !== void 0)
       return this.final(message3, this.clientFirst, server.serverFirst);
     return { bytes: message3, done: true };
   }
   async final(message3, first, serverFirst) {
-    const got = exchangeOf(first, serverFirst, latin(message3.subarray(5)));
+    const got = exchangeOf(first, serverFirst, latin2(message3.subarray(5)));
     if (!got) return { bytes: message3, done: true };
     const x = got.exchange;
+    const binding = this.header === END_POINT ? this.server.binding : void 0;
+    const serverFinal = `c=${channelOf(this.header, binding)},r=${got.nonce}`;
     const values = usable(
       await this.asks.scram({
         clientFirstBare: x.clientFirstBare,
@@ -19559,16 +19672,19 @@ var PgClient = class {
       })
     );
     const [entry, ...more] = Object.entries(values);
-    if (!entry || more.length > 0) return { bytes: message3, done: true };
+    const own = { bytes: frame3(112, `${serverFinal},p=${base64Of(got.proof)}`), done: true };
+    if (!entry || more.length > 0)
+      return serverFinal === x.clientFinalBare ? { bytes: message3, done: true } : own;
     const [placeholder, value2] = entry;
     const fake = await scramKeys(placeholder, x);
-    if (!sameBytes(fake.proof, got.proof)) return { bytes: message3, done: true };
-    const real = await scramKeys(saslprep(value2), x);
+    if (!sameBytes(fake.proof, got.proof))
+      return serverFinal === x.clientFinalBare ? { bytes: message3, done: true } : own;
+    const real = await scramKeys(saslprep(value2), { ...x, clientFinalBare: serverFinal });
     this.server.expect = {
       real: `v=${base64Of(real.serverSignature)}`,
       fake: `v=${base64Of(fake.serverSignature)}`
     };
-    const bytes = frame3(112, `${x.clientFinalBare},p=${base64Of(real.proof)}`);
+    const bytes = frame3(112, `${serverFinal},p=${base64Of(real.proof)}`);
     for (const k of [real.proof, real.serverSignature, fake.proof, fake.serverSignature]) k.fill(0);
     return { bytes, values, done: true };
   }
@@ -19967,7 +20083,7 @@ function idle() {
   return new Promise((resolve2) => setTimeout(() => resolve2(IDLE2), SCRUB_IDLE_MS));
 }
 function sealedConn(conn, s) {
-  const pg = new PgServer();
+  const pg = new PgServer(s.binding);
   const scope = s.broker.sessions.scope(s.pid, s.host);
   const writer = substitutes(s) ? new SessionWriter(conn, s, pg, scope) : void 0;
   const observed = {
@@ -20258,6 +20374,8 @@ function secure(prepared, seal) {
       const session = sealing({ ...seal, engine }, raw2, made2.info, prepared.options.servername);
       if (!session) return made2;
       made2.info.substitutes = substitutes(session);
+      if (made2.info.substitutes && session.verified)
+        session.binding = await endPointBinding(made2.info.peerCertificates[0]);
       return { conn: sealedConn(made2.conn, session), info: made2.info };
     } finally {
       prepared.own?.release();
@@ -22291,6 +22409,18 @@ var WasmProcess = class {
       throw err;
     }
   }
+  async complain(line) {
+    const stderr = this.fds.has(2) ? this.fds.get(2).file : void 0;
+    if (!stderr?.write || stderr.sealed || stderr.clipboard) return false;
+    const bytes = new TextEncoder().encode(`${line}
+`);
+    const timeout = new Promise((r) => setTimeout(() => r(0), 1e3));
+    const sent = await Promise.race([stderr.write(bytes, AbortSignal.timeout(1e3)), timeout]).then(
+      (n) => n,
+      () => 0
+    );
+    return sent > 0;
+  }
   async clipboardComplaint(err) {
     const name2 = this.options.clipboardName;
     if (name2 === void 0 || !(err instanceof KernelError) || err.detail === void 0) return;
@@ -23766,6 +23896,29 @@ function outOfMemory(opts, data) {
   }
   return true;
 }
+function workerError(event) {
+  return String(event.message ?? "worker error");
+}
+var CrashSlot = class {
+  status;
+  reported = false;
+  report;
+  constructor(report) {
+    this.report = report;
+  }
+  take(status, message3, finish) {
+    if (this.status) return;
+    this.status = status;
+    const done5 = () => {
+      this.reported = true;
+      finish(...status);
+    };
+    void this.report(message3).then(done5, done5);
+  }
+};
+async function crashReport(process, onError, message3) {
+  if (!await process.complain(message3)) onError?.(message3);
+}
 function spawnWasmProcess(opts) {
   const { promise: ready2, resolve: started } = readiness(opts.program.abi);
   const sab = new SharedArrayBuffer(SAB_HEADER_BYTES + SAB_DEFAULT_WINDOW_BYTES);
@@ -23816,9 +23969,11 @@ function spawnWasmProcess(opts) {
   const jsThreads = jsThreadsOf(opts, process, token, dispatch2, clocks, header3);
   const { promise: exited, resolve: settle3 } = Promise.withResolvers();
   let done5 = false;
+  const crash = new CrashSlot((message3) => crashReport(process, opts.onError, message3));
   let endedBy;
   const finish = (code, sig) => {
     if (done5) return;
+    if (crash.status && !crash.reported) return;
     done5 = true;
     started(true);
     clocks.freeze();
@@ -23847,8 +24002,9 @@ function spawnWasmProcess(opts) {
     } else if (data?.type === WASM_PROCESS_EXIT) {
       finish(...dying.status(data.code));
     } else if (data?.type === WASM_PROCESS_ERROR) {
-      if (!dying.ending) opts.onError?.(String(data.message));
-      finish(...dying.status(data.code));
+      const status = dying.status(data.code);
+      if (dying.ending) finish(...status);
+      else crash.take(status, String(data.message), finish);
     } else if (data?.type === WASM_THREAD_SPAWN && data.thread) {
       spawnThread(data.thread);
     } else if (data?.type === JS_THREAD_SPAWN && jsThreads) {
@@ -23858,8 +24014,7 @@ function spawnWasmProcess(opts) {
   const onMessage = (event) => handle(event.data);
   const onError = (event) => {
     event.preventDefault();
-    opts.onError?.(String(event.message ?? "worker error"));
-    finish(CRASHED);
+    crash.take([CRASHED], workerError(event), finish);
   };
   worker.addEventListener("message", onMessage);
   worker.addEventListener("error", onError);
@@ -26697,7 +26852,7 @@ var RULE = new RegExp(
   String.raw`^(NOPASSWD\s+)?(\S+)\s+(?:\(([^()\s]+)\)\s+)?(?:Cwd\s+(${WORD})\s+)?Cmnd(?:\s+(.*))?$`
 );
 var TERM = /^[A-Za-z0-9._+-]+$/;
-var PLAIN = /^[A-Za-z0-9_@%+=:,./-]+$/;
+var PLAIN2 = /^[A-Za-z0-9_@%+=:,./-]+$/;
 var USAGE = "usage: sudo [-n] [-u user] [--] command [args...]\n       sudo -l";
 function failed2(errno3, error) {
   return { error, errno: errno3 };
@@ -26724,7 +26879,7 @@ function splitWords(text) {
   return words2;
 }
 function quoteWord(word) {
-  return PLAIN.test(word) ? word : `'${word.replaceAll("'", `'\\''`)}'`;
+  return PLAIN2.test(word) ? word : `'${word.replaceAll("'", `'\\''`)}'`;
 }
 function validWho(who) {
   if (who === "ALL") return true;