@ai-ecoverse/slicc-kernel 1.153.0 → 1.154.0

package/README.md

@@ -454,7 +454,7 @@ The module's default export (or its `main` export) is called with a context and
 - `sudo(args)`, what the [`sudo`](#sudo) command calls: `args` are its arguments after `sudo`, and it resolves with `{ pid }`, the command the kernel started as the program's child, to `wait` for; `{ run }`, an argv to run as the caller (with `users: 'off'`); `{ list }`, the text of `sudo -l`; or `{ error, errno }`, the message to print;
 - `crontab({ action, user?, text? })`, what the [`crontab`](#cron) command calls: `action` is `'list'`, `'remove'` or `'install'` (with the table as `text`), on the caller's own table or, for an effective uid of 0, on `user`'s. It resolves with `{ text }` (the table for `list`, `''` otherwise) or `{ error }`, the message to print. A malformed call is `EINVAL`;
 - `net`: `listen({ port, host, backlog })` and `connect({ host, port, signal })` (`host` defaults to `127.0.0.1`) on the kernel's loopback, the same sockets WASIX programs use, so a JS server is reached by other processes, by the page as `<port>.kernel.localhost` (`loopbackFetch`, `dial`) and by attached clients. A listener has its `port` (as bound, so port `0` picks a free one), `accept({ signal })`, `close()` and `for await` over its connections. A connection has `local` and `remote` addresses, `readable` and `writable` web streams (closing the writable shuts down the sending side, so the peer reads the end), and `close()`. The loopback is IPv4 (`127.0.0.1` by default, or `0.0.0.0`), so an IPv6 host such as `::1` fails with `EADDRNOTAVAIL` for both `listen` and `connect`, and binding and connecting fail as they would for a WASIX program (`EADDRINUSE`, `ECONNREFUSED`, `EADDRNOTAVAIL`). `sync.net.listen` takes the same options and gives the same listener, bound and listening when it returns, so its `port` is known at once, as Node's `listen()` needs ([#1398](https://github.com/ai-ecoverse/slicc-kernel/issues/1398)); it needs the sync lane. A blocked accept, read or write waits without holding anything in the kernel, so aborting it or closing the socket leaves nothing behind. A write to a connection the peer closed fails with `EPIPE` and no `SIGPIPE`;
-- `net.connect({ host, port, tls: { servername, alpn, rejectUnauthorized, ca, path, cert, key, passphrase, sni, checkHostname } })` takes one of two paths. By default it's **A1, TLS through the transport** ([#914](https://github.com/ai-ecoverse/slicc-kernel/issues/914)), described first below. For a destination the uplink routes it can also be **A2, a TLS handshake in the kernel** ([#922](https://github.com/ai-ecoverse/slicc-kernel/issues/922)), described after it. `conn.tls.path` (`'transport'` or `'kernel'`) and `conn.tls.substitutes` say which one was taken.
+- `net.connect({ host, port, tls: { servername, alpn, rejectUnauthorized, ca, path, cert, key, passphrase, sni, checkHostname, keylog } })` takes one of two paths. By default it's **A1, TLS through the transport** ([#914](https://github.com/ai-ecoverse/slicc-kernel/issues/914)), described first below. For a destination the uplink routes it can also be **A2, a TLS handshake in the kernel** ([#922](https://github.com/ai-ecoverse/slicc-kernel/issues/922)), described after it. `conn.tls.path` (`'transport'` or `'kernel'`) and `conn.tls.substitutes` say which one was taken.
   - **What it does:** there's no handshake in the kernel. The connection carries plain HTTP/1.1 (and WebSocket upgrades) to the realm proxy's HTTP path for the origin `https://<servername or host>[:port]`, exactly as a `CONNECT` through `127.0.0.1:3128` does after the kernel terminates its TLS. The transport (the page's `fetch` or WebSocket, or the uplink's) makes the real TLS connection and verifies it. So `https.request` over a socket, keep-alive agents, `agent-base` and `wss://` clients work with the transport's semantics. That includes sealed placeholders in headers, which reach the transport exactly as from `ctx.fetch`.
   - **The `tls` property:** the connection's `tls` is `{ path: 'transport', substitutes: true, protocol: 'transport', alpnProtocol: 'http/1.1', authorized: true, servername }`. `authorized` means the transport verified the server. There's no peer certificate chain and no TLS version of the kernel's own, so don't read it as a real handshake's result.
   - **Options:** the transport always verifies, so `rejectUnauthorized: false` is accepted and changes nothing. Outside the uplink, a custom `ca` is refused (`ENOTSUP`), and so is an `alpn` list without `http/1.1` (`EPROTONOSUPPORT`). The kernel's own loopback never goes to the transport. A `host` of `localhost` or `127.x` makes the handshake in the kernel instead (Loopback, below), so with nothing listening it's `ECONNREFUSED`. The rest of it (`*.localhost`, `0.0.0.0`, `::1`, and any loopback `servername` for another host) is `ENOTSUP` at connect, as `ctx.fetch` refuses `https:` and `wss:` there. `host.slicc.internal` goes to the transport under its policy, as for `ctx.fetch`.
@@ -502,6 +502,7 @@ The module's default export (or its `main` export) is called with a context and
       - `pfx` is `ENOTSUP`: pass `cert` and `key`.
       - A server that requires a certificate and gets none refuses with an alert. On TLS 1.2 that fails the connect (`ERR_SSL_HANDSHAKE_FAILURE`). On TLS 1.3 the client's side of the handshake is already done, so the next read or write fails with `ERR_SSL_FATAL_ALERT`, as Node's fails after `secureConnect`.
       - **A fatal alert from the server**, at the handshake or after it, is in the error: its `detail` ends in ` (alert <n>)`, and a JS program's error has `alert: n`, the alert's description number (116 certificate_required, 40 handshake_failure).
+    - **`keylog: true`** ([#1504](https://github.com/ai-ecoverse/slicc-kernel/issues/1504), tls-engine 4.2.0-10) gives the session's NSS key log lines as `conn.tls.keylog`, a frozen list of strings: `CLIENT_RANDOM …` on TLS 1.2, the four `…_TRAFFIC_SECRET…` lines on TLS 1.3, the lines Node's `keylog` event and `SSLKEYLOGFILE` carry. **They are the session's secrets: anyone holding them and a capture of the traffic can read it.** So a keylogged session is never sealed (`substitutes: false`; a placeholder goes out as written), and `keylog` on the transport path (A1, where the page makes the TLS) is `ENOTSUP`. Without `keylog` the engine collects nothing. The kernel wipes its copies once the lines are in the reply (the engine zeroes its buffer as it hands them out); the lines reach the program as JS strings, which can't be wiped, so they live as long as the program keeps them, as with its own `key`. A TLS server takes `keylog` too (`listen({ tls })`, `secure(conn, { server: true })`), for every connection it serves.
     - **`sni: false`** sends no server name. The leaf is still checked against `servername` exactly as with SNI.
     - **`checkHostname: false`** checks the chain (trust, validity, usage) but **not that the leaf names `servername`**. The connection reports `hostnameChecked: false`, and `hostnameMatches` says what the skipped check found.
       - **The caller must then check the server's identity itself**, as slicc-jsh does with Node's `checkServerIdentity` and `peerCertificates[0]`; pass it only when the program supplied one.

package/dist/kernel-worker.js

@@ -8049,7 +8049,7 @@ function satisfies(version, range2) {
 }
 
 // src/version.ts
-var KERNEL_VERSION = true ? "1.153.0" : "0.0.0-dev";
+var KERNEL_VERSION = true ? "1.154.0" : "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
@@ -17364,6 +17364,7 @@ var TLS_SERVER_REQUEST_CERT = 1;
 var TLS_SERVER_REQUIRE_CERT = 2;
 var TLS_SERVER_SELECT = 4;
 var TLS_HANDSHAKE_SELECT = 2;
+var TLS_KEYLOG = 8;
 var SCRATCH = 64 * 1024;
 var EOF = -1;
 var TlsError = class extends Error {
@@ -17431,6 +17432,9 @@ var TlsEngine = class {
     if (!ptr) throw this.error(this.m._tls_last_error(), "server certificate");
     return new TlsLeaf(this, this.m, ptr);
   }
+  get keylogs() {
+    return typeof this.m._tls_keylog === "function";
+  }
   get serverSelect() {
     return typeof this.m._tls_server_select === "function";
   }
@@ -17461,9 +17465,11 @@ var TlsEngine = class {
       this.m._free(ptr);
     }
   }
-  intoScratch(fn) {
+  intoScratch(fn, secret = false) {
     const n = fn(this.scratch, SCRATCH);
-    return n > 0 ? this.taken(n) : n;
+    const out = n > 0 ? this.taken(n) : n;
+    if (secret && n > 0) this.m.HEAPU8.fill(0, this.scratch, this.scratch + n);
+    return out;
   }
   get sessionControls() {
     return typeof this.m._tls_client_cert === "function";
@@ -17674,6 +17680,14 @@ var TlsSession = class {
   get version() {
     return this.c._tls_version(this.ptr);
   }
+  keylog() {
+    const drain2 = this.m._tls_keylog;
+    const out = this.engine.intoScratch((p, max) => drain2(this.ptr, p, max), true);
+    if (!(out instanceof Uint8Array)) return [];
+    const text = new TextDecoder().decode(out);
+    out.fill(0);
+    return text.split("\n").filter((line) => line.length > 0);
+  }
   get sni() {
     const out = this.engine.intoScratch(
       (p, max) => this.m._tls_sni(this.ptr, p, max)
@@ -19310,7 +19324,7 @@ function isIP(name2) {
   return ipv4Bytes(name2) !== void 0 || name2.includes(":") && ipv6Groups(name2) !== void 0;
 }
 function clientFlags(o) {
-  return (o.insecure ? TLS_CLIENT_INSECURE_SKIP_VERIFY : 0) | (o.sni === false ? TLS_CLIENT_NO_SNI : 0) | (o.checkHostname === false ? TLS_CLIENT_VERIFY_CHAIN_ONLY : 0);
+  return (o.insecure ? TLS_CLIENT_INSECURE_SKIP_VERIFY : 0) | (o.sni === false ? TLS_CLIENT_NO_SNI : 0) | (o.checkHostname === false ? TLS_CLIENT_VERIFY_CHAIN_ONLY : 0) | (o.keylog ? TLS_KEYLOG : 0);
 }
 function openSession(o) {
   return o.engine.clientSession(o.store, o.servername, o.alpn, clientFlags(o));
@@ -19425,7 +19439,8 @@ async function infoOf(o, session) {
     peerCertificates: chain2,
     ...controlsOf(o, session, protocol, chain2, shape),
     verified: verdictOf(o, session),
-    handshakeAt: Date.now()
+    handshakeAt: Date.now(),
+    ...o.keylog ? { keylog: session.keylog() } : {}
   };
 }
 var FATAL_ALERT = -30592;
@@ -19545,7 +19560,7 @@ async function serverHandshake(conn, session, inbox, hooks) {
     }
   }
 }
-async function tlsServer(conn, session, clientCerts, select) {
+async function tlsServer(conn, session, clientCerts, select, keylog = false) {
   let first;
   const watched = {
     ...conn,
@@ -19568,7 +19583,8 @@ async function tlsServer(conn, session, clientCerts, select) {
       servername: session.sni,
       authorized: clientCerts && chain2.length > 0 && code === void 0,
       ...clientCerts && chain2.length > 0 && code ? { authorizationError: code } : {},
-      peerCertificates: chain2
+      peerCertificates: chain2,
+      ...keylog ? { keylog: session.keylog() } : {}
     };
     return { conn: plaintext(conn, session, inbox), info };
   } catch (err) {
@@ -22461,7 +22477,8 @@ function sessionOf(info, servername) {
     } : {},
     servername,
     peerCertificates: info.peerCertificates.map(encode),
-    ...controls(info)
+    ...controls(info),
+    ...info.keylog ? { keylog: info.keylog } : {}
   };
 }
 function controls(info) {
@@ -22603,11 +22620,14 @@ async function prepareWith(support, req, servername, cert) {
     insecure: req.insecure === true,
     ...req.sni === false ? { sni: false } : {},
     ...req.checkHostname === false ? { checkHostname: false } : {},
+    ...req.keylog === true ? { keylog: true } : {},
     clientCertificate: cert !== void 0,
     bundled: own === void 0
   };
   let session;
   try {
+    if (req.keylog === true && !engine.keylogs)
+      throw new KernelError("ENOTSUP", "the installed tls engine has no key log");
     const controls2 = req.sni === false || req.checkHostname === false || cert !== void 0;
     if (controls2 && !engine.sessionControls) {
       throw new KernelError("ENOTSUP", "the installed tls engine has no client certificates");
@@ -22655,7 +22675,7 @@ function secure(prepared, seal) {
     try {
       const made2 = await tlsClient(raw2, prepared.options);
       const engine = prepared.options.engine;
-      const session = sealing({ ...seal, engine }, raw2, made2.info, prepared.options.servername);
+      const session = prepared.options.keylog ? void 0 : sealing({ ...seal, engine }, raw2, made2.info, prepared.options.servername);
       if (!session) return made2;
       made2.info.substitutes = substitutes(session);
       if (made2.info.substitutes && session.verified)
@@ -22768,25 +22788,31 @@ function certFlags(req) {
   if (!req.requestCert) return 0;
   return req.rejectUnauthorized === false ? TLS_SERVER_REQUEST_CERT : TLS_SERVER_REQUIRE_CERT;
 }
-function flagsOf(req) {
-  if (!req.select) return certFlags(req);
+var CERT_FLAGS = TLS_SERVER_REQUEST_CERT | TLS_SERVER_REQUIRE_CERT;
+function selectFlag(req) {
+  if (!req.select) return 0;
   if (req.alpn && req.alpn.length > 0)
     throw new KernelError("EINVAL", "ERR_TLS_ALPN_CALLBACK_WITH_PROTOCOLS: alpn with select");
-  return certFlags(req) | TLS_SERVER_SELECT;
+  return TLS_SERVER_SELECT;
+}
+function flagsOf(req) {
+  return certFlags(req) | selectFlag(req) | (req.keylog ? TLS_KEYLOG : 0);
 }
-async function engineOf(proc, select) {
+async function engineOf(proc, { select, keylog }) {
   const engine = await supportOf(proc.net).engine();
   if (!engine.serverSessions)
     throw new KernelError("ENOTSUP", "the installed tls engine has no server sessions");
+  if (keylog && !engine.keylogs)
+    throw new KernelError("ENOTSUP", "the installed tls engine has no key log");
   if (select && !engine.serverSelect)
     throw new KernelError("ENOTSUP", "the installed tls engine has no server selection");
   return engine;
 }
-async function importedLeaf(proc, own, select) {
+async function importedLeaf(proc, own, needs = {}) {
   const cert = certBytes(own);
   let engine;
   try {
-    engine = await engineOf(proc, select);
+    engine = await engineOf(proc, needs);
   } catch (err) {
     wipe(cert);
     throw err;
@@ -22816,12 +22842,12 @@ async function serverOf(proc, req) {
   delete req.cert;
   if (!own && !req.select)
     throw new KernelError("EINVAL", "ERR_INVALID_ARG_VALUE: a server needs cert and key");
-  const { engine, leaf } = own ? await importedLeaf(proc, own, req.select) : { engine: await engineOf(proc, true), leaf: void 0 };
+  const { engine, leaf } = own ? await importedLeaf(proc, own, req) : { engine: await engineOf(proc, { ...req, select: true }), leaf: void 0 };
   let mine;
   try {
     mine = req.ca && req.ca.length > 0 ? storeOf(engine, req.ca) : void 0;
     const flags2 = flagsOf(req);
-    const store = mine ?? (flags2 & ~TLS_SERVER_SELECT ? await defaultStore(engine, supportOf(proc.net).roots) : void 0);
+    const store = mine ?? (flags2 & CERT_FLAGS ? await defaultStore(engine, supportOf(proc.net).roots) : void 0);
     return {
       engine,
       leaf,
@@ -22855,7 +22881,8 @@ function servedOf(info) {
     authorized: info.authorized,
     ...info.authorizationError ? { authorizationError: info.authorizationError } : {},
     peerCertificates: info.peerCertificates.map(encode),
-    cipher: info.cipher
+    cipher: info.cipher,
+    ...info.keylog ? { keylog: info.keylog } : {}
   };
 }
 var selections = /* @__PURE__ */ new WeakMap();
@@ -22878,13 +22905,14 @@ async function serveSecure(proc, socket, req) {
   const { engine, leaf, alpn, store, flags: flags2 } = server;
   const limit = handshakeSignal(proc, server.timeoutMs);
   const { pausedAt, select } = pausing(limit.signal);
-  const certs = (flags2 & ~TLS_SERVER_SELECT) !== 0;
+  const certs = (flags2 & CERT_FLAGS) !== 0;
   const run2 = socket.secureLink(
     (raw2) => tlsServer(
       raw2,
       engine.serverSession(leaf, alpn, store, flags2),
       certs,
-      flags2 & TLS_SERVER_SELECT ? select : void 0
+      flags2 & TLS_SERVER_SELECT ? select : void 0,
+      (flags2 & TLS_KEYLOG) !== 0
     ),
     limit.signal,
     (reason) => !shared && reason === timedOut
@@ -23354,7 +23382,7 @@ var NOT_HTTP_PORTS = /* @__PURE__ */ new Set([
 ]);
 var HOST_NAME = /^[A-Za-z0-9.-]+$|^\[?[0-9A-Fa-f:.]+\]?$/;
 function sessionControls(req) {
-  return req.sni === false || req.checkHostname === false || req.clientCert !== void 0;
+  return req.sni === false || req.checkHostname === false || req.clientCert !== void 0 || req.keylog === true;
 }
 function wantsKernel(req) {
   if (req.path === "kernel") return true;