The workspace declared 0.1.0, the stable target, although nothing has
been released: it was a development placeholder. The workspace crates
and the Nix packages now carry 0.0.1-alpha.0, the first prerelease
toward 0.0.1, and the README records that 0.1.0 was never published.
Application, package and WIT interface versions are unchanged.
Following the move of weft-runtime and weft-app-shell logging to
standard error: their stdout carries only the readiness line, and appd
records stderr at info level and other stdout output at debug level.
weft-runtime and weft-app-shell logged to standard output, which carries
their readiness line to weft-appd. weft-appd keeps that stream only at
debug level, so the runtime's warnings and errors, such as a failed
grant or an ended IPC connection, never reached its log, and the lines
carried terminal colour codes.
Both now log to standard error, which weft-appd records at info level,
with colours only on a terminal. In the nested desktop Counter check,
the runtime's own lines appear in weft-appd's log; the grants check
reads the hangup message from standard error.
A runtime outlived the weft-appd that started it. Runtimes run in their
own systemd scopes, outside weft-appd's service, and a component that
waits for messages, as the Counter and Notes demos do, keeps polling a
closed connection forever. Each time weft-appd stopped or restarted and
restored the previous session, the earlier runtimes stayed behind.
The connection is the session: a thread waits for it to hang up, without
reading from it, and the runtime then exits whatever the component is
doing. That covers weft-appd closing the connection, weft-appd ending,
and the runtime ending the connection itself after a failed send or an
overlong message. A runtime given an IPC socket it cannot connect to now
fails instead of running unreachable. weft-appd's relay notes that it
must not shut down half of the connection, which would now end the
session.
tests/runtime/check_grants.py runs the real runtime on the Counter
component over a Unix socket: it answers an increment, and once the test
closes its end the runtime exits with status 0 within 10 seconds; with
the watcher removed it keeps running and the check fails. A unit test
checks that the wait sees a hangup but neither wakes on nor consumes
pending data; CI's runtime-grants job now runs the runtime's unit tests
with its features. The nested desktop Counter and Notes checks pass with
this runtime.
The VM ran without graphics, so the desktop could not be seen, and
weft-appd was pointed at the mount helper's store path, which cannot be
set-user-ID, so verified package images could not mount.
The VM opens a graphics window, with tty0 as the primary console and the
serial console as a secondary one. weft-mount-helper is installed
through security.wrappers, setuid root and executable only by the
users group, built to run cryptsetup's veritysetup, and weft-appd uses
/run/wrappers/bin/weft-mount-helper.
weft-mount-helper is meant to be installed setuid root, but it trusted
its caller entirely: it ran veritysetup, mount and umount from the
caller's PATH, mounted a caller's image at any directory, such as over
/etc, and unmounted any mountpoint. Any local user could have gained
root through it.
It now mounts only at an empty directory
/run/user/<uid>/weft/mnt/<name> of the real user, where weft-appd puts
its mountpoints, with every component from <uid> on owned by that user,
not writable by others and opened without following symbolic links,
and mounts through the opened directory, so the path cannot be swapped
meanwhile. It opens the image and hash tree with the real user's
permissions, checks the root hash is a hex digest, mounts read-only with
nosuid, nodev and noexec through mount(2), and unmounts only an EROFS
filesystem at such a directory. veritysetup runs from the absolute path
fixed at build time (WEFT_VERITYSETUP, /usr/sbin/veritysetup by
default), with an empty environment. Devices are named
weft-<uid>-<name>, so a user reaches only their own; a device left by an
interrupted mount is closed by the next mount or unmount at that
directory, and a user may have at most 64 open, counted from the
kernel's list of device-mapper devices under a root-owned lock. Closed standard streams
are reopened on /dev/null before anything else is opened, and errors and
panics are printed as one-line messages.
Run setuid as nobody with a PATH holding a hostile veritysetup and
mount, the helper refuses /etc and another user's directory as
mountpoints, a symbolic link to /etc, a file nobody cannot read, a
malformed root hash, and unmounting /etc or a directory with no image;
a valid request reaches veritysetup at its fixed path, also with the
standard streams closed, and the hostile programs never run. Unit tests cover the mountpoint rules.
The tty1 login hook ran systemctl --user start graphical-session.target,
which systemd refuses (RefuseManualStart=yes), so none of the NixOS
session's services started. The units in infra/systemd were wanted by
graphical.target, a system target, although weft-appd's needs the
session user's runtime and home directories and the compositor publishes
its socket to the user manager; run as system units the shell could
never learn the socket.
weft-session.target binds graphical-session.target and wants the
compositor, shell and weft-appd, in the NixOS configuration and as a
user unit in infra/systemd; the login hook starts it. The services are
part of the graphical session, the shell no longer hardcodes the
compositor's socket, and the compositor's units unset WAYLAND_DISPLAY
and DISPLAY so a restarted compositor does not take them for an
enclosing session and pick the nested backend. As a user unit, weft-appd
drops ProtectSystem= and PrivateTmp=, which a user manager implements
with PrivateUsers=yes, under which the setuid mount helper cannot mount
verified images. docs/building.md adds the VM's disabled graphics and
its mount helper, which the Nix store cannot hold setuid, to what still
keeps the image from a working desktop.
Rendered from the NixOS configuration, and as installed from
infra/systemd, the units pass systemd-analyze --user verify.
The services started after the compositor had no way to learn its
socket: the NixOS shell service hardcoded wayland-1, weft-appd's service
had no WAYLAND_DISPLAY at all, so the app shells it starts could not
connect, and the plain unit's comment claimed the compositor posted the
socket to the environment, which it did not.
Started by systemd, the compositor now sets WAYLAND_DISPLAY in the user
manager with systemctl --user set-environment right after creating its
socket and before reporting readiness, so the units ordered after it
inherit it. The winit backend now reports readiness too, as a Type=notify
unit expects.
The reference session could not show the system UI or open an app, even
with every package built:
- weft-servo-shell ignores command-line arguments, yet
infra/systemd/servo-shell.service passed it the page path, and the
binary's packaged fallback named a path no package provides. The
Nix package did not install the page and its NixOS service did not
name it either, so the shell exited at startup.
- The NixOS weft-appd user service was wanted by nothing, so it never
started, and it had no WEFT_APP_SHELL_BIN, so every launch would stop
before its UI host started.
The weft-servo-shell package now installs the page as
share/weft/shell/system-ui.html, the binary falls back to that path in
the package's active revision, the systemd unit drops the ignored
argument, and the NixOS service sets WEFT_SYSTEM_UI_HTML to the package's
copy. weft-appd is wanted by the graphical session and is given the app
shell. docs/building.md lists what still keeps the image from a working
desktop: the Servo source hash, servo-embed in the shell packages and the
fixed Wayland socket name.
The launcher button, app icons and taskbar entries were custom elements
with click handlers only: none could be focused, named or activated from
the keyboard, and the launcher overlay neither took nor returned focus.
They are now buttons with accessible names and a visible focus ring. The
launcher is a modal dialog that a Super tap or the Apps button opens
with focus on its first app; Tab moves between apps, Enter opens one and
Escape or another Super tap closes it, returning focus to the Apps
button. Each taskbar entry has an activate and a close button reachable
with Tab, and focus moves to a remaining control when an entry closes or
goes away. Notifications, including the offer to force quit, are
announced as status.
Servo does not tell the document when its window loses keyboard focus,
so weft-servo-shell calls window.weftShellBlurred() then and the launcher
closes; the next Super tap opens it again. Servo does not evaluate
prefers-reduced-motion either, so the page has no transitions.
tests/frame/check_system_ui.py drives the real page on the nested
desktop with keys: opening apps from the launcher, reaching the shell
with a Super tap from an application, a Super chord that stays with the
app and leaves no Super modifier held there, activating and closing apps
from the taskbar, the launcher closing when the shell loses focus, and
toggling it. It fails without the compositor's Super handling or the
focus-loss call.
The catalog followed the store's directory listing, so the launcher's
order, and with it its keyboard order, could change between scans. Apps
are listed by name, ignoring case, then by ID.
From an application window there was no keyboard path to the system
shell: only a pointer click on the taskbar strip raised the panel.
The Super keys now belong to the compositor and are never delivered to
an application. A tap, Super pressed and released without another key,
activates the shell's panel, raising it with keyboard focus, and then
delivers the tap to it so the shell can open its launcher; a key or a
pointer button pressed meanwhile makes it no tap. Keys pressed while
Super is held reach the focused window with the Super modifier: a client
is sent the modifiers whenever a key the compositor takes changes them,
so none stays held there. With several panels, the first registered one
is the shell's.
The frame limit constant was inserted between spawn_ipc_relay's doc
comment and its cfg(unix) attribute, so the attribute applied to the
constant instead. A non-Unix build would have had two definitions of
the function.
The size is now checked before the line ending, so a frame one byte
over the limit is refused even when its line break arrives in the same
read. A message that is not UTF-8 ends the relay, as it did before,
rather than reaching the page with replacement characters. The test now
also covers a message at exactly the limit ending in CRLF.
The session's IPC relay read component messages with read_line inside
select!, into a buffer created anew on each pass. When a message from
the page won the select while a component message was half read, the
read part was lost, and the page received the remainder as a message of
its own. The line was also unbounded.
The relay now keeps the frame being read across passes and fills it
with read_until, which keeps partial reads when cancelled. It ends the
relay on a line longer than any message the runtime sends.
A new test writes half a component message, has the relay forward a page
message, then completes it and checks that it arrives whole. On the
previous code the test receives only the second half. It also checks
that an overlong line ends the relay.
Discarding wl-copy's output also lost its error message, such as a
missing Wayland connection. Its standard error is now kept and read
only when it fails, which is always before it leaves its selection
server.
Other fixes:
- An output over the limit is reported as such, instead of as the
helper dying of the broken pipe.
- The clipboard is read as any text type, since the content is checked
as UTF-8 anyway.
- Notification bodies are sent with markup escaped, since notification
servers may render links and images.
- A failed wait for a helper kills and reaps it.
wl-copy forks a process that keeps serving the selection. That process
inherits the helper's output pipes, so reading them to the end would
block a clipboard write until the selection changed. wl-copy's output is
now discarded, and its failure is reported by exit status.
The clipboard and notification imports ran wl-paste, wl-copy and
notify-send with no deadline and no size limits, and took the clipboard
text whole. A notification's icon could be any path or URL, and nothing
said which app sent it, so an app could pass one off as the system's.
Each helper now runs with a 5-second deadline, after which it is killed
and the call fails. Clipboard text is at most 1 MiB in either direction.
A notification's title is at most 256 bytes and its body 4096, its icon
must be an icon theme name, and it is sent with the app's ID as the
application name.
Unit tests run real processes for the deadline, the output limit, input
passing and failure reporting, and check the notification bounds.
check_grants.py still passes.
Pruning compared a list of the declared capabilities with the set of
approved ones by length. A manifest repeating a capability could
therefore keep an approval it no longer declared. The two are now
compared as sets.
weft-pack approve <id> <capability>... replaced the app's approval
instead of adding to it. It also accepted any app ID and any
capability, which let an approval cover a capability declared later. It
now adds to the approval, requires the app to be installed, and for a
package weft-pack can read, requires each listed capability to be
declared. The docs state the remaining limits for verified images.
weft-pack approve read only the user store, so an app in the system
store, or installed as a verified image, could not be approved. The
remedy the launch refusal named also did not work.
approve now resolves the package in weft-appd's store order. It also
accepts the capabilities by name, which is how an image is approved,
since weft-pack cannot read its manifest.
An install or rollback without --approve now drops approvals for
capabilities the package no longer declares. A capability declared
again later therefore asks again. Both commands report what still needs
approval. weft-appd validates capabilities without side effects first,
then refuses unapproved ones, then derives grants, so an unsupported
capability is reported as such and not as one needing approval. The
docs state that approvals are per user.
Every capability a package declared was granted at launch, so a signed
package received all the permissions it asked for. Blueprint 5.2 rules
that out.
A package now gets only the capabilities the user approved. weft-pack
install --approve approves those the installed package declares, and
weft-pack approve <id> approves those of the installed app later.
Without approval, install lists what still needs it. The approval is
recorded in $XDG_DATA_HOME/weft/approvals/<id>. weft-appd refuses to
launch an app declaring a capability the record does not hold, with
403 and the capabilities named, after refusing unknown or unsupported
ones as before.
An update that declares a new capability needs approval again, and
uninstalling forgets the approval. Private app data is a minimal
execution resource and needs no approval, so Notes and the existing
fixtures are unchanged.
Unit tests cover the approval record, install and approve, an update
adding a capability, uninstall, and appd refusing and then launching.
tests/frame/check_update.py launches a real app declaring notifications:
it is refused until weft-pack approve, then runs.
The relative link in the race test climbed one level too high, so it
pointed at a directory that does not exist and could not catch a read
that left the granted directory.
The race test could finish before its swapping thread first ran, so in
some runs nothing was exercised and the test failed. The link now
exists from the start. The test runs until it has seen both reads that
stay inside and reads refused for leading out, and it also swaps in a
relative link that climbs out.
Other fixes:
- A request line ending in CRLF is measured without the CRLF.
- Responses that the client stops reading time out like requests do.
- Temporary file names include the portal's start time, so a file left
by an earlier instance cannot collide with a new one.
The test binary passed 30 runs in a row.