@ai-ecoverse/slicc-kernel 1.136.3 → 1.136.4

package/README.md

@@ -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.3" : "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();
@@ -26734,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 };
@@ -26761,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;