@ai-ecoverse/slicc-kernel 1.64.0 → 1.64.1

package/README.md

@@ -561,6 +561,7 @@ With `users: 'enforce'` the kernel checks every file call that reaches it agains
 - **`access(2)`:** `faccessat` (bash's `[ -r ]`, `test -w`) answers from the same checks, with the real uid and gid, or the effective ones with `AT_EACCESS`, for Emscripten programs, and for WASI programs through `slicc_fs.path_access` (see [File modes and the umask](#file-modes-and-the-umask)).
 - **Exec:** running a program by path needs `x` on it, and `r` too when it's a script (`#!` or a `binfmt` suffix); a WASI or Emscripten binary needs only `x`. Root needs an `x` bit as well. Commands found by name, and `/usr/bin` and `/bin`, are always executable; a user's own commands in `~/.local/share/pnpm/bin` are reached through the user's home, so another user gets `EACCES` there, as for any file. A refused exec is `EACCES` (126 in bash).
 - **The layout:** with `users: 'report'` or `'enforce'`, the kernel gives its own paths an owner and a mode when they have no owner record yet: on a fresh root, and once on a root from before owners. These are `/` `0755`, `/root` `0700`, `/home` `0755`, `/etc` `0755`, `/etc/passwd` and `/etc/group` `0644`, `/usr` and `/usr/local` `0755`, `/node_modules` (or the `modules` option) and the system `PNPM_HOME` `0755`, all root's. A path that has a record keeps it, so an admin's `chmod 711 /home` or `chown cone /node_modules` lasts across restarts; a mounted path is left to its mount, and a path below a symlinked directory is stamped where it really is. Only a root that records owners is stamped: the OPFS root with its sidecar, which the page and the Node entry (in memory) both use; a custom root file system without owner records is left as it is. The directory for files removed while open, `/.slicc-unlinked`, is made root's `0700`. `/tmp` is the exception: it is set to `1777` at every start. Emscripten programs see `/` at `0755`, `/dev` at `0755`, `null`, `zero`, `full`, `random`, `urandom` and `tty` at `0666`, and `/dev/shm` at `1777`. With `users: 'off'` nothing is stamped. Paths the embedder makes (bios's `/opt` and `/var/lib/slicc`) are the embedder's to set, and `/etc/sudoers` comes with `sudo`.
+- **Terminals:** a terminal from `openTerminal` belongs to its session's user, with group `tty` when `/etc/group` has one (the user's own group otherwise), mode `0620`; a pseudo-terminal's slave `/dev/pts/N` belongs to the uid and gid that opened `/dev/ptmx`, mode `0620`. Opening one by name (`/dev/ttyN`, `/dev/pts/N`, from every runtime) needs both `r` and `w`, so only its owner and root open it: the kernel's terminal descriptor always reads and writes, so the group's `w` bit (`write`, `wall` on Linux) does not let a group member open it. `/dev/tty` is the opener's own controlling terminal and is not checked, and descriptors a process inherited (across `sudo` or a `setresuid` too) keep working. Emscripten programs' `stat` of `/dev/ttyN` and `/dev/pts/N` shows the owner and mode. With `users: 'off'` terminals have no owner, as before.
 - **A client's `fs`:** checked as the client's user; a page's client (root) passes.
 
 With `users: 'enforce'` not yet the default, no release turns it on before `sudo` exists.

package/dist/kernel-worker.js

@@ -1484,6 +1484,11 @@ var Created = class {
 function deny(g, op, path, errno = "EACCES") {
   g.dac.denied({ pid: g.pid, uid: g.cred.euid, op, path, errno });
 }
+var TTY_MODE = 400;
+function ttyOpenable(g, tty) {
+  if (!g || !tty.owner || permits(g.cred, tty.owner, R_OK | W_OK, false)) return;
+  deny(g, "open", tty.name ?? "/dev/tty");
+}
 async function need(g, op, path, want, options = {}, shown = path) {
   const walked = await access(g.fs, g.cred, path, want, options);
   if (walked.denied !== void 0) deny(g, op, shown);
@@ -3196,10 +3201,18 @@ var UserDb = class {
     };
   }
   async lookup(user) {
+    return (await this.lookupTerminal(user))?.account;
+  }
+  async ttyGroup() {
+    return parsed(parseGroup(await this.read(GROUP, DEFAULT_GROUP))).find((g) => g.name === "tty")?.gid;
+  }
+  async lookupTerminal(user) {
     const { passwd, group } = await this.tables();
     const key = typeof user === "number" ? "uid" : "name";
     const row = parsed(passwd).find((r) => r[key] === user);
-    return row && this.account(row, parsed(group));
+    const groups = parsed(group);
+    const tty = groups.find((g) => g.name === "tty")?.gid;
+    return row && { account: this.account(row, groups), tty };
   }
   async list() {
     const { passwd, group } = await this.tables();
@@ -9816,6 +9829,7 @@ var KernelTty = class {
   waiters = [];
   hungUp = false;
   name;
+  owner;
   onRead;
   readers = 0;
   screen;
@@ -10159,10 +10173,11 @@ var PtyTable = class {
     this.signal = signal;
     this.onRead = onRead;
   }
-  open() {
+  open(owner) {
     let index = 0;
     while (this.pairs.has(index)) index += 1;
     const pair = new PtyPair(index, this.signal, (p) => this.pairs.delete(p.index), this.onRead);
+    if (owner) pair.slave.owner = { uid: owner.uid, gid: owner.gid, mode: TTY_MODE };
     this.pairs.set(index, pair);
     return { pair, master: pair.master() };
   }
@@ -10175,6 +10190,10 @@ var PtyTable = class {
     return [...this.pairs.keys()].sort((a, b) => a - b);
   }
 };
+function ptsNumber(path) {
+  const m = /^\/dev\/pts\/(\d+)$/.exec(path);
+  return m ? Number(m[1]) : void 0;
+}
 var PTY_OPS = [
   "pty-open",
   "pty-slave-open",
@@ -10202,11 +10221,12 @@ function ptySyscall(req, ctx) {
   switch (req.op) {
     case "pty-open": {
       if (!ctx.ptys) throw new KernelError("ENOENT");
-      return json4(ctx.fds.install(ctx.ptys.open().master, 3));
+      return json4(ctx.fds.install(ctx.ptys.open(ctx.owner).master, 3));
     }
     case "pty-slave-open": {
       if (!ctx.ptys) throw new KernelError("ENOENT");
       const pair = ctx.ptys.get(req.n);
+      ttyOpenable(ctx.guard, pair.slave);
       const fd = ctx.fds.install(pair.openSlave(), 3);
       if (!req.noctty) ctx.jobs?.acquireTerminal(ctx.pid, pair.slave);
       return json4(fd);
@@ -11022,6 +11042,7 @@ var SYSCALL_OPS = /* @__PURE__ */ new Set([
   "fd-promote",
   "fd-open-tty",
   "fd-tty-names",
+  "fd-tty-owner",
   "tty-get",
   "tty-set",
   "tty-winsz",
@@ -11223,7 +11244,9 @@ var WasmProcess = class {
       }
       if (isPtySyscall(req)) {
         const { ptys, jobs } = this.options;
-        return ptySyscall(req, { pid: this.pid, fds: this.fds, ptys, jobs });
+        const owner = this.options.owners ? this.ttyOwner() : void 0;
+        const guard2 = this.guarded();
+        return ptySyscall(req, { pid: this.pid, fds: this.fds, ptys, jobs, guard: guard2, owner });
       }
       return await this.procSyscall(req, cancelled);
     } catch (e) {
@@ -11355,6 +11378,25 @@ var WasmProcess = class {
     const want = (access2 === 1 ? 0 : R_OK) | (access2 !== 0 || req.truncate ? W_OK : 0);
     await openable(g, "open", req.path, want, req.create === true);
   }
+  openTty(name2) {
+    const tty = name2 === void 0 ? this.controllingTerminal() : this.options.jobs?.terminalNamed(name2);
+    if (!tty) throw new KernelError("ENXIO");
+    if (name2 !== void 0) ttyOpenable(this.guarded(), tty);
+    return this.fds.install(tty.file(), 3);
+  }
+  guarded() {
+    const { guard: guard2 } = this.options;
+    return guard2 && { fs: guard2.fs, dac: guard2.dac, cred: this.cred, pid: this.pid };
+  }
+  ttyOwner() {
+    return { uid: this.cred.euid, gid: this.cred.egid, mode: TTY_MODE };
+  }
+  terminalByName(name2) {
+    const n = ptsNumber(name2);
+    const tty = n === void 0 ? this.options.jobs?.terminalNamed(name2) : this.options.ptys?.get(n).slave;
+    if (!tty) throw new KernelError("ENOENT");
+    return tty;
+  }
   newOwner() {
     if (!this.options.owners) return void 0;
     return { uid: this.cred.euid, gid: this.cred.egid, mode: 438 & ~this.umask };
@@ -11458,13 +11500,12 @@ var WasmProcess = class {
           if (!req.keep) await Promise.resolve(this.fds.close(req.from));
         }
         return { ok: true, kind: "void" };
-      case "fd-open-tty": {
-        const tty = req.name === void 0 ? this.controllingTerminal() : this.options.jobs?.terminalNamed(req.name);
-        if (!tty) throw new KernelError("ENXIO");
-        return { ok: true, kind: "json", json: this.fds.install(tty.file(), 3) };
-      }
+      case "fd-open-tty":
+        return { ok: true, kind: "json", json: this.openTty(req.name) };
       case "fd-tty-names":
         return { ok: true, kind: "json", json: this.options.jobs?.terminalNames() ?? [] };
+      case "fd-tty-owner":
+        return { ok: true, kind: "json", json: this.terminalByName(req.name).owner ?? null };
       case "fd-select": {
         const { read, write, timeoutMs } = req;
         if (this.owed && timeoutMs !== 0) {
@@ -15086,7 +15127,12 @@ var Launcher = class {
   }
   async account(user) {
     if (typeof user === "object") return user;
-    const found = await this.users.lookup(user ?? 0);
+    return (await this.terminalAccount(user)).account;
+  }
+  async terminalAccount(user) {
+    if (typeof user === "object")
+      return { account: user, tty: this.owners ? await this.users.ttyGroup() : void 0 };
+    const found = await this.users.lookupTerminal(user ?? 0);
     if (!found) throw fsError("ENOENT", `no user ${String(user)}`);
     return found;
   }
@@ -15108,7 +15154,7 @@ var Launcher = class {
     return { cwd, file, planned };
   }
   async openTerminal(argv, options) {
-    const account = await this.account(options.user);
+    const { account, tty: ttyGroup } = await this.terminalAccount(options.user);
     const { cwd, file, planned } = await this.starting(argv, options.cwd, account);
     if (!planned) throw new Error(`${file}: command not found`);
     let leader = 0;
@@ -15118,6 +15164,7 @@ var Launcher = class {
     );
     tty.onRead = () => this.settling.reading(this.jobs.tcgetpgrp(tty, leader));
     tty.name = `/dev/tty${++this.terminals}`;
+    if (this.owners) tty.owner = { uid: account.uid, gid: ttyGroup ?? account.gid, mode: TTY_MODE };
     tty.setSize(options.cols ?? 80, options.rows ?? 24);
     const fds = new FdTable();
     const stdio = tty.file();