@ai-ecoverse/slicc-kernel 1.148.1 → 1.149.0

package/README.md

@@ -454,7 +454,7 @@ The module's default export (or its `main` export) is called with a context and
 - `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.
   - **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 (`localhost`, `*.localhost`, `127/8`, `0.0.0.0`, `::1`, as `servername` or as `host`) is `ENOTSUP` at connect, as `ctx.fetch` refuses `https:` and `wss:` there. Connect in plain text to a kernel server. `host.slicc.internal` goes to the transport under its policy, as for `ctx.fetch`.
+  - **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`.
   - **Non-HTTP protocols aren't carried:**
     - the well-known TLS ports of other protocols (465 SMTPS, 993 IMAPS, 995 POP3S, 636 LDAPS, 853, 8883 MQTT, 6697 IRC, 5671 AMQP and the like) are refused at `connect` with `EPROTONOSUPPORT`;
     - non-HTTP first bytes on any other port get a `400` and a close;
@@ -504,6 +504,15 @@ The module's default export (or its `main` export) is called with a context and
       - **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.
       - With `rejectUnauthorized: false` it's `EINVAL`.
     - **STARTTLS:** `net.connect({ socket: conn, host, tls })` upgrades an open plain connection to an uplink destination in place, as Node's `tls.connect({ socket })` does. It resolves with a connection whose streams now carry the decrypted bytes and whose `tls` is the session. Don't hold a pending read on the plain connection while it upgrades. Pass `host` (or `tls.servername`): the plain connection only knows the address it reached, so without a name the certificate is checked against that IP, and a certificate for the host name fails.
+    - **Loopback:** `net.connect({ host, port, tls })` to `localhost` or a `127.x` address makes the handshake in the kernel too, over the loopback connection, with the same options as A2 (`ca`, `cert`/`key`, `sni`, `checkHostname`). Nothing on loopback is ever substituted (`substitutes: false`).
+    - **A TLS server** ([#1401](https://github.com/ai-ecoverse/slicc-kernel/issues/1401)), with the program's own certificate and key: `net.listen({ port, host, tls: { cert, key, passphrase, alpn, ca, requestCert, rejectUnauthorized } })` (and `sync.net.listen`) gives a listener whose connections are already secured, and `net.secure(conn, { server: true, cert, key, … })` secures one accepted connection. `net.secure(conn, tls)` without `server: true` is the client upgrade, as `connect({ socket })`.
+      - `cert` and `key` take the same forms as a client certificate, and are refused the same way, at `listen` (or `secure`) before anything is accepted: a key for another certificate is `ERR_OSSL_X509_KEY_VALUES_MISMATCH`, a wrong passphrase `ERR_OSSL_BAD_DECRYPT`.
+      - `alpn` is the server's list in order of preference; the first one the client also offers wins, and a client that offers ALPN but none of these fails the handshake.
+      - `requestCert` needs `ca` (the roots a client certificate must reach; else `EINVAL`). With it the handshake fails without a client certificate that verifies, unless `rejectUnauthorized: false`, which only asks for one and reports the verdict.
+      - A connection's `tls` is `{ path: 'kernel', protocol, alpnProtocol, servername (the SNI the client sent, or ''), authorized (whether a client certificate verified), authorizationError?, peerCertificates (the client's chain) }`.
+      - On a `listen({ tls })` listener, the kernel handshakes accepted connections concurrently, from the first `accept` on, and `accept` (and `for await`) yields each as its handshake finishes, so a client that connects and stays silent doesn't hold up the next. It holds at most `backlog` (up to 64) connections in a handshake or handshaken but not yet taken; beyond that it stops accepting, leaving the rest in the kernel's backlog, until one finishes or is taken. A connection whose handshake fails is closed and never yielded. `secure()` rejects instead.
+      - `handshakeTimeout` (milliseconds, 120000 by default, as Node's) ends a handshake that hasn't finished: the connection is closed with `ERR_TLS_HANDSHAKE_TIMEOUT`. A handshake, server or loopback client, waits without holding the program's other calls, and an aborted `accept({ signal })` or `connect({ signal })` ends it. A signal delivered to the program doesn't interrupt a handshake, as with `SA_RESTART`.
+      - **The key:** the kernel hands it to the engine once per listener (once per `secure()` call) and wipes its own copies; the engine keeps its copy until the listener is closed, and not in errors, logs, `ps`, `/proc` or the page. A forked child that inherits the listener shares that one copy, and it's freed when the last process closes it. **The program's own `key` string or `Buffer` stays in its realm**: JavaScript strings can't be wiped, so the kernel can't erase what the program holds.
     - **Sealed values in an A2 session** ([#1090](https://github.com/ai-ecoverse/slicc-kernel/issues/1090)) are substituted only at a credential position, only in a session the kernel verified itself (by its bundled roots, or by a vault anchor), and only as the vault allows. `substitutes` means the session **may** substitute: a placeholder at a recognized position will be offered to the vault, and whether a value comes back is the vault's and the anchor check's decision. It's true when all of these hold:
       - `verified` is true, or the engine can verify a chain on its own (wasm-tls-engine 4.2.0-5's `tls_chain_verify`) and the server name isn't an IP literal, so a vault anchor may verify the session (below);
       - ALPN didn't agree `h2`;

package/dist/kernel-worker.js

@@ -5954,6 +5954,9 @@ function link(a, b) {
   a.attach({ rx: ba, tx: ab });
   b.attach({ rx: ab, tx: ba });
 }
+var SERVE_CHUNK = 64 * 1024;
+var NEVER_ABORTED = new AbortController().signal;
+var EMPTY = new Uint8Array(0);
 var KernelSocket = class _KernelSocket {
   net;
   domain;
@@ -6151,6 +6154,54 @@ var KernelSocket = class _KernelSocket {
     if (this.state !== "open") throw new KernelError("EISCONN");
     return this.dial(addr, route2, secure2);
   }
+  serving;
+  served = false;
+  get loopbackLinked() {
+    return this.state === "connected" && !this.switch;
+  }
+  async secureLink(make, signal = NEVER_ABORTED) {
+    const raw2 = this.connection();
+    if (this.switch || this.served || this.writeShut || this.readShut)
+      throw new KernelError("EINVAL");
+    signal.throwIfAborted();
+    this.served = true;
+    let handshaking = true;
+    const view2 = {
+      localAddr: "",
+      remoteAddr: "",
+      read: async () => {
+        const bytes = await raw2.rx.read(SERVE_CHUNK, handshaking ? signal : void 0).catch(() => EMPTY);
+        return bytes.length > 0 ? bytes : null;
+      },
+      write: (bytes) => raw2.tx.write(bytes),
+      closeWrite: () => raw2.tx.closeWrite(),
+      close: () => {
+        raw2.rx.closeRead();
+        raw2.tx.closeWrite();
+      }
+    };
+    let made2;
+    const abandon = () => view2.close();
+    signal.addEventListener("abort", abandon, { once: true });
+    try {
+      made2 = await make(view2);
+    } catch (err) {
+      view2.close();
+      this.readShut = true;
+      this.writeShut = true;
+      this.changes.wake();
+      throw signal.aborted ? signal.reason : err;
+    } finally {
+      handshaking = false;
+      signal.removeEventListener("abort", abandon);
+    }
+    this.link = uplinkLink(made2.conn, (err) => {
+      this.reset = err instanceof KernelError && err.code === "EPROTO" ? err : new KernelError("ECONNRESET");
+      this.changes.wake();
+    });
+    this.changes.wake();
+    return made2.info;
+  }
   upgradeSecure(make) {
     if (this.state !== "connected") throw new KernelError("ENOTCONN");
     if (!this.switch) throw new KernelError("EOPNOTSUPP");
@@ -6282,6 +6333,8 @@ var KernelSocket = class _KernelSocket {
     }
     if (this.boundAt) this.net.release(this.boundAt, this, this.named);
     this.boundAt = void 0;
+    this.serving?.release();
+    this.serving = void 0;
     this.changes.wake();
   }
   static pair(net, domain, cred) {
@@ -7855,7 +7908,7 @@ function satisfies(version, range2) {
 }
 
 // src/version.ts
-var KERNEL_VERSION = true ? "1.148.1" : "0.0.0-dev";
+var KERNEL_VERSION = true ? "1.149.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
@@ -10354,7 +10407,7 @@ async function followLinks(fs, path) {
   return current;
 }
 var NOBODY = { ruid: -1, euid: -1, suid: -1, rgid: -1, egid: -1, sgid: -1, groups: [] };
-var EMPTY = new Uint8Array(0);
+var EMPTY2 = new Uint8Array(0);
 function quiet(promise) {
   return promise.catch(() => void 0);
 }
@@ -10437,13 +10490,13 @@ function withCommandDirs(fs, names2, userDir = async () => void 0, owners = fals
     return target?.path;
   }
   const absent2 = (err) => {
-    if (missing3(err)) return EMPTY;
+    if (missing3(err)) return EMPTY2;
     throw err;
   };
   async function content(path, err) {
     if (!missing3(err) || !(await linked2(path))?.isFile) throw err;
     const target = await redirected2(path);
-    return target === void 0 ? EMPTY : fs.readFileBuffer(target).catch(absent2);
+    return target === void 0 ? EMPTY2 : fs.readFileBuffer(target).catch(absent2);
   }
   const ranged2 = rangedOps(fs);
   async function stat(path, real) {
@@ -16717,6 +16770,8 @@ function realmCa(owner, store) {
 var TLS_CLIENT_INSECURE_SKIP_VERIFY = 1;
 var TLS_CLIENT_NO_SNI = 2;
 var TLS_CLIENT_VERIFY_CHAIN_ONLY = 4;
+var TLS_SERVER_REQUEST_CERT = 1;
+var TLS_SERVER_REQUIRE_CERT = 2;
 var SCRATCH = 64 * 1024;
 var EOF = -1;
 var TlsError = class extends Error {
@@ -16765,6 +16820,35 @@ var TlsEngine = class {
       this.m._free(name2);
     }
   }
+  get serverSessions() {
+    return typeof this.m._tls_server_new === "function";
+  }
+  importLeaf(chain2, key, pass2) {
+    const leafImport = this.m._tls_leaf_import;
+    const keyLen = key[0] === 45 ? key.length + 1 : key.length;
+    const ptr = this.withBytes(
+      chain2,
+      (c) => this.withSecret(
+        key,
+        (k) => this.withSecret(
+          pass2,
+          (p) => leafImport(c, chain2.length, k, keyLen, pass2.length > 0 ? p : 0, pass2.length)
+        )
+      )
+    );
+    if (!ptr) throw this.error(this.m._tls_last_error(), "server certificate");
+    return new TlsLeaf(this, this.m, ptr);
+  }
+  serverSession(leaf, alpn, clientCa, flags2) {
+    const open2 = this.m._tls_server_new;
+    const wire = alpnWire(alpn);
+    const ptr = this.withBytes(
+      wire,
+      (p) => open2(leaf.ptr, wire.length > 0 ? p : 0, wire.length, clientCa?.ptr ?? 0, flags2)
+    );
+    if (!ptr) throw this.error(this.m._tls_last_error(), "tls server");
+    return new TlsSession(this, this.m, ptr);
+  }
   withBytes(bytes, fn) {
     const ptr = this.put(bytes);
     try {
@@ -16969,6 +17053,12 @@ var TlsSession = class {
   get version() {
     return this.c._tls_version(this.ptr);
   }
+  get sni() {
+    const out = this.engine.intoScratch(
+      (p, max) => this.m._tls_sni(this.ptr, p, max)
+    );
+    return out instanceof Uint8Array ? new TextDecoder().decode(out) : "";
+  }
   get alpn() {
     const out = this.engine.intoScratch((p, max) => this.c._tls_alpn(this.ptr, p, max));
     return out instanceof Uint8Array ? new TextDecoder().decode(out) : void 0;
@@ -17471,7 +17561,7 @@ var Upload = class {
     }
   }
 };
-var EMPTY2 = new Uint8Array(0);
+var EMPTY3 = new Uint8Array(0);
 function message2(e) {
   return e instanceof Error ? e.message : String(e);
 }
@@ -17546,8 +17636,8 @@ var HttpHandles = class {
     const entry = {
       abort,
       head: Promise.resolve({ ok: true, kind: "void" }),
-      body: once(EMPTY2),
-      left: EMPTY2,
+      body: once(EMPTY3),
+      left: EMPTY3,
       done: false,
       reading: Promise.resolve(),
       cancel: async () => void 0,
@@ -18785,6 +18875,46 @@ async function tlsClient(conn, o, taken = new Uint8Array(0)) {
     throw err;
   }
 }
+async function serverHandshake(conn, session, inbox) {
+  for (; ; ) {
+    let done5;
+    try {
+      done5 = session.handshake();
+    } catch (err) {
+      await send(conn, session).catch(() => void 0);
+      const text = err instanceof TlsError ? err.message : String(err);
+      throw new KernelError("EPROTO", `ERR_SSL_HANDSHAKE_FAILURE: ${text}${alertOf(session)}`);
+    }
+    await send(conn, session);
+    if (done5) return;
+    if (!await inbox.more()) {
+      throw new KernelError(
+        "ECONNRESET",
+        "the client closed the connection during the TLS handshake"
+      );
+    }
+  }
+}
+async function tlsServer(conn, session, clientCerts) {
+  const inbox = new Ciphertext(conn, session);
+  try {
+    await serverHandshake(conn, session, inbox);
+    const chain2 = session.peerChain();
+    const code = clientCerts ? verifyCode(session.verifyResult) : void 0;
+    const info = {
+      protocol: session.version === 772 ? "TLSv1.3" : "TLSv1.2",
+      alpnProtocol: session.alpn ?? false,
+      servername: session.sni,
+      authorized: clientCerts && chain2.length > 0 && code === void 0,
+      ...clientCerts && chain2.length > 0 && code ? { authorizationError: code } : {},
+      peerCertificates: chain2
+    };
+    return { conn: plaintext(conn, session, inbox), info };
+  } catch (err) {
+    session.free();
+    throw err;
+  }
+}
 
 // src/kernel/net/tls-chain.ts
 var CN_MISMATCH = 4;
@@ -19237,7 +19367,7 @@ var RANK = {
 };
 var CR2 = 13;
 var LF2 = 10;
-var EMPTY3 = new Uint8Array(0);
+var EMPTY4 = new Uint8Array(0);
 function register(automaton, sources, ids, bytes, source) {
   const key = Array.from(bytes).join(",");
   let id2 = ids.get(key);
@@ -19417,12 +19547,12 @@ function compile(secrets, options = {}) {
       return { text: decoder4.decode(bytes), hits };
     },
     stream() {
-      let pending = EMPTY3;
+      let pending = EMPTY4;
       const hits = /* @__PURE__ */ new Map();
       const run2 = (final) => {
         if (c.secrets.length === 0 || pending.length === 0) {
           const out = pending;
-          pending = EMPTY3;
+          pending = EMPTY4;
           return out;
         }
         const result = pass(c, pending, final);
@@ -19436,7 +19566,7 @@ function compile(secrets, options = {}) {
           return run2(false);
         },
         idle() {
-          return pending.length < FRAGMENT ? run2(true) : EMPTY3;
+          return pending.length < FRAGMENT ? run2(true) : EMPTY4;
         },
         end() {
           return run2(true);
@@ -21598,6 +21728,7 @@ function sealedConn(conn, s) {
 }
 
 // src/kernel/net/tls-uplink.ts
+var handshakeAbort = (proc) => proc.cancelled ?? proc.blocking();
 var isIP2 = (text) => ipv4Bytes(text) !== void 0 || text.includes(":") && ipv6Groups(text) !== void 0;
 var LABEL2 = /^(?!-)[A-Za-z0-9-]{1,63}(?<!-)$/;
 function serverName(name2) {
@@ -21718,6 +21849,9 @@ function takeCert(req) {
   const cert = req.clientCert;
   if (!cert) return void 0;
   delete req.clientCert;
+  return certBytes(cert);
+}
+function certBytes(cert) {
   if (!Array.isArray(cert.chain) || cert.chain.length === 0 || typeof cert.key !== "string")
     throw new KernelError("EINVAL", "ERR_INVALID_ARG_VALUE: cert and key go together");
   let ders;
@@ -21893,8 +22027,32 @@ async function connectSecure(proc, socket, host, port, req) {
   }
   return sessionOf(info, servername);
 }
+async function loopbackSecure(proc, socket, servername, req) {
+  const prepared = await prepare2(supportOf(proc.net), req, servername);
+  let ran = false;
+  try {
+    const info = await socket.secureLink(async (raw2) => {
+      ran = true;
+      try {
+        return await tlsClient(raw2, prepared.options);
+      } finally {
+        prepared.own?.release();
+      }
+    }, handshakeAbort(proc));
+    return sessionOf({ ...info, substitutes: false }, servername);
+  } finally {
+    if (!ran) {
+      prepared.options.session.free();
+      prepared.own?.release();
+    }
+  }
+}
 async function upgradeSecure(proc, socket, req) {
   const peer = socket.peer;
+  if (socket.loopbackLinked) {
+    const host2 = req.servername || (peer?.family === "inet" ? peer.host : "localhost");
+    return loopbackSecure(proc, socket, serverName(host2), req);
+  }
   const host = req.servername || (peer?.family === "inet" ? peer.host : "");
   const servername = serverName(host);
   const port = peer?.family === "inet" ? peer.port : 0;
@@ -21909,6 +22067,120 @@ async function upgradeSecure(proc, socket, req) {
   }
 }
 
+// src/kernel/net/tls-server.ts
+var HANDSHAKE_TIMEOUT_MS = 12e4;
+function leafOf(engine, cert) {
+  try {
+    return engine.importLeaf(cert.chain, cert.key, cert.pass);
+  } catch (err) {
+    throw keyRefused(err, cert.pass.length > 0 && encryptedKey(cert.key));
+  } finally {
+    wipe(cert);
+  }
+}
+function storeOf(engine, ca) {
+  const store = engine.store();
+  try {
+    for (const der2 of ca) store.add(base64Der(der2));
+    return store;
+  } catch (err) {
+    store.release();
+    throw new KernelError("EINVAL", `ERR_INVALID_ARG_VALUE: ca: ${err.message}`);
+  }
+}
+function flagsOf(req, store) {
+  if (!req.requestCert) return 0;
+  if (!store) throw new KernelError("EINVAL", "ERR_INVALID_ARG_VALUE: requestCert needs a ca");
+  return req.rejectUnauthorized === false ? TLS_SERVER_REQUEST_CERT : TLS_SERVER_REQUIRE_CERT;
+}
+function timeoutOf(req) {
+  const ms = req.handshakeTimeout ?? HANDSHAKE_TIMEOUT_MS;
+  if (!Number.isInteger(ms) || ms <= 0)
+    throw new KernelError(
+      "EINVAL",
+      "ERR_OUT_OF_RANGE: handshakeTimeout must be a positive integer"
+    );
+  return ms;
+}
+function handshakeSignal(proc, ms) {
+  const timer = new AbortController();
+  const id2 = setTimeout(
+    () => timer.abort(new KernelError("EPROTO", "ERR_TLS_HANDSHAKE_TIMEOUT: TLS handshake timeout")),
+    ms
+  );
+  return {
+    signal: AbortSignal.any([handshakeAbort(proc), timer.signal]),
+    done: () => clearTimeout(id2)
+  };
+}
+async function serverOf(proc, req) {
+  const own = req.cert;
+  delete req.cert;
+  if (!own) throw new KernelError("EINVAL", "ERR_INVALID_ARG_VALUE: a server needs cert and key");
+  const cert = certBytes(own);
+  let engine;
+  try {
+    engine = await supportOf(proc.net).engine();
+    if (!engine.serverSessions)
+      throw new KernelError("ENOTSUP", "the installed tls engine has no server sessions");
+  } catch (err) {
+    wipe(cert);
+    throw err;
+  }
+  const leaf = leafOf(engine, cert);
+  let store;
+  try {
+    store = req.ca && req.ca.length > 0 ? storeOf(engine, req.ca) : void 0;
+    const flags2 = flagsOf(req, store);
+    return {
+      engine,
+      leaf,
+      store,
+      alpn: req.alpn ?? [],
+      flags: flags2,
+      timeoutMs: timeoutOf(req),
+      release() {
+        leaf.release();
+        store?.release();
+      }
+    };
+  } catch (err) {
+    leaf.release();
+    store?.release();
+    throw err;
+  }
+}
+async function listenSecure(proc, socket, req) {
+  if (!socket.listening) throw new KernelError("EINVAL", "not a listening socket");
+  const server = await serverOf(proc, req);
+  socket.serving?.release();
+  socket.serving = server;
+}
+async function serveSecure(proc, socket, req) {
+  const shared = req.listener?.serving;
+  if (req.listener && !shared) throw new KernelError("EINVAL", "the listener has no tls");
+  const server = shared ?? await serverOf(proc, req);
+  try {
+    const { engine, leaf, alpn, store, flags: flags2 } = server;
+    const limit = handshakeSignal(proc, server.timeoutMs);
+    const info = await socket.secureLink(
+      (raw2) => tlsServer(raw2, engine.serverSession(leaf, alpn, store, flags2), flags2 !== 0),
+      limit.signal
+    ).finally(limit.done);
+    return {
+      path: "kernel",
+      protocol: info.protocol,
+      alpnProtocol: info.alpnProtocol,
+      servername: info.servername,
+      authorized: info.authorized,
+      ...info.authorizationError ? { authorizationError: info.authorizationError } : {},
+      peerCertificates: info.peerCertificates.map(encode)
+    };
+  } finally {
+    if (!shared) server.release();
+  }
+}
+
 // src/kernel/unix-dgram.ts
 var SOL_SOCKET3 = 1;
 var SO_TYPE3 = 3;
@@ -22071,7 +22343,9 @@ var SOCKET_OPS = [
   "sock-sendto",
   "sock-recvfrom",
   "sock-tls",
-  "sock-tls-upgrade"
+  "sock-tls-upgrade",
+  "sock-tls-serve",
+  "sock-tls-listen"
 ];
 function socketAt(fds, fd) {
   const file = anySocketAt(fds, fd);
@@ -22147,6 +22421,14 @@ async function socketSyscall(req, proc) {
       return ok3(await secureConnect(req, proc));
     case "sock-tls-upgrade":
       return ok3(await upgradeSecure(proc, socketAt(fds, req.fd), req));
+    case "sock-tls-serve": {
+      const { from, ...rest2 } = req;
+      const listener = from === void 0 ? {} : { listener: socketAt(fds, from) };
+      return ok3(await serveSecure(proc, socketAt(fds, req.fd), { ...rest2, ...listener }));
+    }
+    case "sock-tls-listen":
+      await listenSecure(proc, socketAt(fds, req.fd), req);
+      return ok3({});
     default:
       return datagram(req, proc);
   }
@@ -24578,6 +24860,7 @@ var WasmProcess = class {
       fds: this.fds,
       net: this.net,
       blocking: () => this.blockingSignal(cancelled),
+      cancelled,
       resolve: (name2, family, blocking) => resolver.resolve(name2, family, blocking),
       cred: () => ({ pid: this.pid, uid: this.cred.euid, gid: this.cred.egid }),
       stamp: () => this.connectorStamp(),