@ai-ecoverse/slicc-kernel 1.63.0 → 1.64.0

package/README.md

@@ -560,7 +560,7 @@ With `users: 'enforce'` the kernel checks every file call that reaches it agains
 - **Opening a file:** an open needs `r` to read and `w` to write or truncate, checked once when the file is opened, in every runtime: Emscripten, WASI (a second open of a path the program already has open is checked as well), JS programs' `ctx.open` and `ctx.fs.writeFile`, and the kernel's own opens. A file the open itself creates is not checked (only its directory is), so `open(O_CREAT | O_WRONLY, 0444)` works. An open descriptor keeps the access it was opened with, through a later `chmod`, and so do descriptors a child inherits. Reads and writes without a descriptor (`ctx.fs.readFile`, `ctx.sync.fs.readFile`) are checked each time.
 - **`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).
-- **`/tmp` and `/dev`:** with `users: 'report'` or `'enforce'`, `/tmp` is `1777` (set again at every start), and Emscripten programs see `/dev` at `0755`, `null`, `zero`, `full`, `random`, `urandom` and `tty` at `0666`, and `/dev/shm` at `1777`. With `users: 'off'` they keep their modes as before.
+- **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`.
 - **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

@@ -427,6 +427,9 @@ var OpfsFs = class {
   trackOwners() {
     this.owners = true;
   }
+  async hasOwner(path) {
+    return ownOf((await this.meta.get([path]))[0]) !== void 0;
+  }
   async ancestry(path) {
     const entries = await this.meta.get(chain(path));
     const out = [];
@@ -6427,6 +6430,7 @@ function withCommandDirs(fs, names, userDir = async () => void 0, owners = false
     ...fs.realpath ? { realpath: fs.realpath.bind(fs) } : {},
     ...fs.chown ? { chown: fs.chown.bind(fs) } : {},
     ...fs.ancestry ? { ancestry: fs.ancestry.bind(fs) } : {},
+    ...fs.hasOwner ? { hasOwner: fs.hasOwner.bind(fs) } : {},
     chmod: (path, mode) => fs.chmod(path, mode),
     utimes: (path, atime, mtime) => fs.utimes(path, atime, mtime),
     lutimes: (path, atime, mtime) => lutimesOf(fs, path, atime, mtime),
@@ -6526,8 +6530,10 @@ var UnlinkedKeeper = class {
   count = 0;
   links = /* @__PURE__ */ new Map();
   linked = /* @__PURE__ */ new Map();
+  dirOwner;
   constructor(fs, holders, rootOf, options = {}) {
     const { locks, owner } = options;
+    this.dirOwner = options.dirOwner;
     this.fs = fs;
     this.holders = holders;
     this.rootOf = rootOf;
@@ -6638,7 +6644,8 @@ var UnlinkedKeeper = class {
       const dir = dirOf(this.rootOf(path));
       const hidden = `${dir}/${this.instance}.${++this.count}`;
       try {
-        await this.fs.mkdir(dir, { recursive: true });
+        const owner = this.dirOwner;
+        await this.fs.mkdir(dir, { recursive: true, ...owner ? { owner } : {} });
         await this.fs.rename(path, hidden);
         await this.linkedName(hidden);
         return hidden;
@@ -8017,6 +8024,10 @@ var MountFs = class {
     if (this.at(real)) throw errnoError("ENOSYS", path);
     return real;
   }
+  async hasOwner(path) {
+    if (this.at(path)) return true;
+    return await this.base.hasOwner?.(path) ?? true;
+  }
   async ancestry(path) {
     const names = chain(normalizePath(path));
     const first = names.findIndex((name2) => this.at(name2));
@@ -14126,6 +14137,16 @@ var NOT_FOUND = 127;
 var DECIDE_MS = 100;
 var INIT_PID = 1;
 var SHARED_DIRS = ["/tmp", "/home"];
+var LAYOUT = [
+  ["/", 493],
+  ["/root", 448],
+  ["/home", 493],
+  ["/etc", 493],
+  [PASSWD, 420],
+  [GROUP, 420],
+  ["/usr", 493],
+  ["/usr/local", 493]
+];
 var encoder3 = new TextEncoder();
 var USERS_MODES = ["off", "report", "enforce"];
 function usersMode(mode = "off") {
@@ -14319,7 +14340,8 @@ var Launcher = class {
       {
         locks: webLocks(),
         busy: (path) => [...this.openFiles].some((nodes) => nodes.holds(path)),
-        owner: options.unlinkOwner
+        owner: options.unlinkOwner,
+        ...this.owners ? { dirOwner: { uid: 0, gid: 0, mode: 448 } } : {}
       }
     );
     this.fs = this.unlinked.wrap(keepingOpen(fs, this.nodes));
@@ -14944,6 +14966,24 @@ var Launcher = class {
       await this.provisionPnpmHome();
     return entry;
   }
+  async stampLayout() {
+    const layout = [
+      ...LAYOUT,
+      [this.modulesDir, 493],
+      [this.pnpmHome, 493],
+      [`/${UNLINKED_DIR}`, 448]
+    ];
+    for (const [path, mode] of layout) {
+      const real = await this.realLayoutPath(path);
+      const fresh = real !== void 0 && !await this.base.hasOwner?.(real);
+      if (fresh) await this.base.chown?.(real, { uid: 0, gid: 0, mode, follow: false });
+    }
+  }
+  async realLayoutPath(path) {
+    if (!await this.base.exists(path)) return void 0;
+    if (path === "/") return path;
+    return joinName(await realDir(this.base, parentOf3(path)), baseName(path));
+  }
   async provisionPnpmHome() {
     await this.base.mkdir(this.pnpmHome, { recursive: true }).catch(() => void 0);
   }
@@ -15017,6 +15057,7 @@ var Launcher = class {
     if (this.owners) await this.base.chmod("/tmp", 1023);
     await this.provisionPnpmHome();
     await this.users.ensure();
+    if (this.owners) await this.stampLayout();
     await writeCaFile(this.base, this.ca).catch(() => void 0);
     this.fstab = this.mountFstab();
   }