From 3ecff58e6abf90821713381db58154732a9498ed Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Fri, 20 Nov 2026 16:43:50 -0800 Subject: [PATCH 1/4] chore(quest): claim quest/m1/browser-sandbox.md Quest-Claim: 85ba48ba03d4ea7b From 3fc9bfb7a821de8b0e920fb920362e9e4a6cd501 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Fri, 20 Nov 2026 17:07:50 -0800 Subject: [PATCH 2/4] feat(scene): run browser sources' renderers in Chromium's sandbox on Linux and macOS The helper no longer passes --no-sandbox. On Linux it first checks, as Chromium does, that the kernel lets the studio's user make a user namespace and another inside it, and fails every browser source saying what to allow where it cannot, rather than let the browser abort. On macOS each helper app enters its Seatbelt sandbox through CEF's libcef_sandbox.dylib before it loads CEF's framework. A browser test proves a page's renderer cannot reach a file the helper can, through its moved root on Linux and its Seatbelt policy on macOS. The nightly software render job allows the studio user namespaces with the AppArmor profile the README gives for Ubuntu. Windows stays in quest/m1/browser-sandbox.md, behind browser sources on Windows. Co-Authored-By: Claude Opus 5.5 --- .github/workflows/nightly.yml | 16 +++++ Cargo.lock | 1 + README.md | 24 ++++++- quest/m1/browser-sandbox-mac-check.md | 30 +++++++++ quest/m1/browser-sandbox.md | 54 ++++++++-------- rs/moq-scene/Cargo.toml | 6 +- rs/moq-scene/src/browser/host.rs | 24 ++++--- rs/moq-scene/src/browser/mod.rs | 2 + rs/moq-scene/src/browser/sandbox.rs | 90 +++++++++++++++++++++++++++ rs/moq-studio/tests/browser.rs | 76 ++++++++++++++++++++++ 10 files changed, 285 insertions(+), 38 deletions(-) create mode 100644 quest/m1/browser-sandbox-mac-check.md create mode 100644 rs/moq-scene/src/browser/sandbox.rs diff --git a/.github/workflows/nightly.yml b/.github/workflows/nightly.yml index 0d48c3c7..33ce61ad 100644 --- a/.github/workflows/nightly.yml +++ b/.github/workflows/nightly.yml @@ -38,6 +38,22 @@ jobs: - uses: ./.github/actions/nix + # Ubuntu's AppArmor lets a program make the user namespaces Chromium's + # sandbox needs only where a profile allows it, and browser sources + # fail without them: the README's profile, for the studio the browser + # tests run. + - name: Allow the studio user namespaces + run: | + sudo tee /etc/apparmor.d/moq-studio >/dev/null <, + include + + profile moq-studio $GITHUB_WORKSPACE/target/debug/moq-studio flags=(unconfined) { + userns, + } + EOF + sudo apparmor_parser -r /etc/apparmor.d/moq-studio + - name: Render run: nix develop --command just render-sw diff --git a/Cargo.lock b/Cargo.lock index 6d515883..bf6ed81c 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -4747,6 +4747,7 @@ dependencies = [ "humantime-serde", "image", "kio", + "libc", "mach2", "moq-audio", "moq-json", diff --git a/README.md b/README.md index abca9afa..7d18de63 100644 --- a/README.md +++ b/README.md @@ -937,9 +937,9 @@ directory can read them. One studio at a time can use the profile: a second one's browser sources fail saying so. Each page renders in a process of its own, so a page that crashes fails only its own source, with the reason, while the stream carries on. A crash of the browser itself fails every browser source. -Either shows at once, since the browser's processes dump no core. Pages run -without Chromium's sandbox, as in OBS, so a page that exploits a browser bug -can do anything you can: add only pages you trust. +Either shows at once, since the browser's processes dump no core. Each page +renders in Chromium's sandbox, so a page that exploits a browser bug still +cannot read your files, keys, or stream credentials. The browser requests only what its pages load, never asking Google for updates, the time, or autofill suggestions on its own, so pages are not spellchecked, which would need a dictionary from Google. Nor does it run @@ -952,6 +952,24 @@ and nothing from a password field. On Linux, except for a page copied on the GPU through an X display, the text goes as plain text that the page's own copy handlers cannot change; on macOS the page copies as it would in a browser. +On Linux the sandbox needs unprivileged user namespaces, and the studio run as +a user other than root. Where the system refuses them, browser sources fail +saying so rather than render a page unsandboxed. Ubuntu refuses them, since +23.10, to any program an AppArmor profile does not allow; as root, allow the +studio, naming the `moq-studio` you run: + +```bash +cat >/etc/apparmor.d/moq-studio <<'EOF' +abi , +include + +profile moq-studio /path/to/moq-studio flags=(unconfined) { + userns, +} +EOF +apparmor_parser -r /etc/apparmor.d/moq-studio +``` + An overlay is a title, lower third, or other graphic written as HTML and CSS, drawn by the studio itself (through [Blitz](https://github.com/DioxusLabs/blitz)) rather than a browser, on every platform. Its CSS animations and transitions diff --git a/quest/m1/browser-sandbox-mac-check.md b/quest/m1/browser-sandbox-mac-check.md new file mode 100644 index 00000000..b332d93f --- /dev/null +++ b/quest/m1/browser-sandbox-mac-check.md @@ -0,0 +1,30 @@ +# [XS] Check sandboxed browser sources in the signed macOS app + +## Goal + +The maintainer has run a browser source in the Developer ID signed, +notarized macOS app, installed from its disk image, and seen its page draw +with its renderer sandboxed, or the fix it needs is written into this Plan. + +## Plan + +[moq-dev/studio#223](https://github.com/moq-dev/studio/pull/223) sandboxes +each page's renderer on macOS. `macos.yml` runs the browser-source tests, +`a_renderer_cannot_read_the_user_s_files` among them, against an ad hoc +signed bundle with the release's hardened runtime and entitlements, but not +against the release's own signature, notarization, and quarantine, which a +download runs under (App Translocation moves a quarantined app to a random +read-only path, from which Chromium builds its sandbox's rules). + +## Waiting + +- Maintainer: on a Mac, download the next release's disk image (or a + `release.yml` run's `macos-arm64` artifact) in a browser, open the app + once from the image and once from Applications, add a browser source such + as `https://webglsamples.org/aquarium/aquarium.html`, and check that it + draws and plays, and that Activity Monitor's Sandbox column (View, Columns) + says Yes for `moq-studio Helper (Renderer)` and `moq-studio Helper (GPU)`. + No reachable Mac runs a signed app, and the release job runs nothing built + until its signing credentials leave the runner; running the browser tests + there was considered and would add a second hour-long build of the test + harness to every release. Check: a comment or this Plan records the result. diff --git a/quest/m1/browser-sandbox.md b/quest/m1/browser-sandbox.md index ab07e476..024fdf54 100644 --- a/quest/m1/browser-sandbox.md +++ b/quest/m1/browser-sandbox.md @@ -1,33 +1,35 @@ -# [L] Chromium's sandbox for browser sources +# [M] Chromium's sandbox for browser sources on Windows ## Goal -A browser source's renderer runs inside Chromium's sandbox on every -platform browser sources run on, so a hostile page, or an overlay site that -gets compromised, cannot read the creator's files, keys, or stream credentials +A browser source's renderer on Windows runs inside Chromium's sandbox, as it +does on Linux and macOS, so a hostile page, or an overlay site that gets +compromised, cannot read the creator's files, keys, or stream credentials through a renderer exploit. The helper passes no `--no-sandbox`. ## Plan -Today every platform starts CEF with `--no-sandbox` -(`rs/moq-scene/src/browser/host.rs`), and the README warns to add only pages -you trust. - -- **Linux:** Chromium's namespace sandbox needs unprivileged user namespaces, - which some distributions restrict (Ubuntu's AppArmor rule since 24.04); - the setuid `chrome-sandbox` fallback needs root to install. Recommendation: - use the namespace sandbox, and when the kernel refuses it, fail the browser - source loudly with what to enable rather than run unsandboxed. -- **macOS:** link CEF's `cef_sandbox` static library into - `moq-browser-helper` and enter the Seatbelt sandbox first thing in its - `main`, as CEF's sample helpers do. Check the renderer's and GPU helper's - entitlements in `packaging/macos/sign.sh` still suffice. -- **Windows:** CEF's sandbox needs its `cef_sandbox.lib` linked into the - executable and `bootstrap.exe`'s layout; land with or after - [Browser sources on Windows](/quest/m0/browser-source/windows.md). -- A test per platform proves a page's renderer cannot open a file outside its - profile. - -## Related - -- [Browser sources on macOS and Windows](/quest/m0/browser-source/README.md) - the browser sources this sandboxes +Linux and macOS landed in +[moq-dev/studio#223](https://github.com/moq-dev/studio/pull/223): on Linux +`moq_scene::browser::sandbox::check` refuses to start CEF where the kernel +refuses the user namespaces Chromium needs, and on macOS each helper app +enters the Seatbelt sandbox through CEF's `libcef_sandbox.dylib` +(`cef::sandbox::Sandbox`) before it loads CEF's framework. + +- CEF's Windows sandbox needs `cef_sandbox.lib` linked into the executable + that runs the subprocesses, with its sandbox info passed to + `execute_process` and `initialize`, and `bootstrap.exe`'s layout. The `cef` + crate's `sandbox` feature, which `moq-scene` leaves off with its other + defaults, builds CEF's wrapper with it. +- Prove it the way `a_renderer_cannot_read_the_user_s_files` in + `rs/moq-studio/tests/browser.rs` does on Linux and macOS: a Windows + `can_read` that asks whether the renderer's restricted, untrusted-integrity + token may open a file the test wrote, where the helper's may. + +## Hosts + +- windows - CEF's Windows sandbox + +## Required + +- [Browser sources on Windows](/quest/m0/browser-source/windows.md) - browser sources run on Windows at all diff --git a/rs/moq-scene/Cargo.toml b/rs/moq-scene/Cargo.toml index 68cbaf16..0714e398 100644 --- a/rs/moq-scene/Cargo.toml +++ b/rs/moq-scene/Cargo.toml @@ -29,7 +29,7 @@ pipewire = ["capture", "moq-video/pipewire", "moq-audio/pipewire"] # process, on Linux and macOS. Off by default: the build downloads the CEF # runtime, or takes it from `CEF_PATH`, and compiles its C++ wrapper. Without # it, a browser source reports that this build cannot render web pages. -cef = ["dep:cef", "dep:objc2", "dep:objc2-app-kit", "dep:objc2-foundation"] +cef = ["dep:cef", "dep:libc", "dep:objc2", "dep:objc2-app-kit", "dep:objc2-foundation"] # CEF's subprocesses on macOS, which run from helper apps of their own in the # app bundle rather than from the studio's executable. @@ -111,6 +111,10 @@ x11rb = { version = "0.13", features = ["dri3"] } # Whether the Wayland display has an output, without which CEF's `initialize` # hangs. Pure Rust, and 0.31 as eframe's winit uses. wayland-client = "0.31" +# Forks a child that makes the user namespaces Chromium's sandbox needs, which +# rustix leaves out, since the child of a threaded process may make only raw +# system calls. Already in the graph. +libc = { version = "0.2", optional = true } # Each is the release already in the graph through wgpu and winit. [target.'cfg(target_os = "macos")'.dependencies] diff --git a/rs/moq-scene/src/browser/host.rs b/rs/moq-scene/src/browser/host.rs index cc01ecb5..419b6bd3 100644 --- a/rs/moq-scene/src/browser/host.rs +++ b/rs/moq-scene/src/browser/host.rs @@ -27,6 +27,17 @@ const COPIED: &str = "moq-studio-copied"; /// Run one of CEF's subprocesses (renderer, GPU, utility, zygote). pub(super) fn subprocess() -> ExitCode { + let args = args::Args::new(); + // On macOS each subprocess enters Chromium's sandbox for its kind itself, + // before CEF's framework loads, as CEF's own helpers do, and leaves it + // only as it exits. Every bundle holds the sandbox's library, so a helper + // that cannot load it panics. On Linux the zygote CEF starts does this. + #[cfg(target_os = "macos")] + let _sandbox = { + let mut sandbox = cef::sandbox::Sandbox::new(); + sandbox.initialize(args.as_main_args()); + sandbox + }; #[cfg(target_os = "macos")] let _framework = match mac::framework(true) { Ok(framework) => framework, @@ -36,7 +47,6 @@ pub(super) fn subprocess() -> ExitCode { } }; let _ = api_hash(sys::CEF_API_VERSION_LAST, 0); - let args = args::Args::new(); let mut app = RendererApp::new(RendererCopy::new()); let code = execute_process(Some(args.as_main_args()), Some(&mut app), std::ptr::null_mut()); ExitCode::from(code.clamp(0, 255) as u8) @@ -171,6 +181,11 @@ fn browse(shared: &Arc, start: Start, reader: Channel, painted_tx: mpsc: ) .map_err(|err| format!("cannot turn off core dumps: {err}"))?; + // Chromium sandboxes every page's renderer, and would abort, not run it + // unsandboxed, where it cannot. + #[cfg(target_os = "linux")] + super::sandbox::check()?; + // Read before CEF starts, which can block for good, as on a display that // never answers, so the studio's end is heard even then. let inbox = Arc::new(Inbox { @@ -613,13 +628,6 @@ wrap_app! { command_line.append_switch_with_value(Some(&"password-store".into()), Some(&"basic".into())); #[cfg(target_os = "macos")] command_line.append_switch(Some(&"use-mock-keychain".into())); - // Chromium's sandbox needs unprivileged user namespaces, which - // Ubuntu's AppArmor and a Flatpak deny, or a setuid-root helper, - // which a user build lacks. Without either, the browser aborts - // rather than run unsandboxed, so the sandbox is off, as in OBS. On - // macOS it needs CEF's sandbox library linked into every helper, - // which the `cef` crate leaves to the app, so it is off there too. - command_line.append_switch(Some(&"no-sandbox".into())); // The browser requests only what its pages load. Otherwise it asks // Google, unprompted, for the network time, for autofill's guesses // at each form a page shows, and for whether AI Mode is offered. diff --git a/rs/moq-scene/src/browser/mod.rs b/rs/moq-scene/src/browser/mod.rs index b313b4fc..932304ce 100644 --- a/rs/moq-scene/src/browser/mod.rs +++ b/rs/moq-scene/src/browser/mod.rs @@ -45,6 +45,8 @@ mod host; mod import; #[cfg(target_os = "macos")] mod mach; +#[cfg(all(target_os = "linux", feature = "cef"))] +mod sandbox; #[cfg(any(target_os = "linux", target_os = "macos"))] pub(crate) use protocol::Open; diff --git a/rs/moq-scene/src/browser/sandbox.rs b/rs/moq-scene/src/browser/sandbox.rs new file mode 100644 index 00000000..38cff5e6 --- /dev/null +++ b/rs/moq-scene/src/browser/sandbox.rs @@ -0,0 +1,90 @@ +//! Whether Chromium can sandbox pages on this Linux system, asked before CEF +//! starts, so a browser source fails saying what to change rather than run a +//! page unsandboxed or leave the browser to abort. + +use std::ffi::CStr; +use std::io; + +/// Fail unless Chromium's namespace sandbox can start: unless the studio runs +/// as a user the kernel lets make a user namespace and another inside it, as +/// Chromium itself checks. Ubuntu's AppArmor, since 23.10, refuses that to any +/// program no profile allows it. Chromium's other sandbox, the setuid-root +/// `chrome-sandbox`, takes root to install, and the copy CEF leaves beside +/// the binary is not setuid, so the studio does not count on it. +pub(super) fn check() -> Result<(), String> { + // SAFETY: neither can fail. + let (uid, gid) = unsafe { (libc::getuid(), libc::getgid()) }; + if uid == 0 { + return Err("Chromium sandboxes no pages for root: run the studio as another user".into()); + } + // Formatted before forking: the child of a threaded process must not + // allocate, since another thread may hold the allocator's lock. + let uid_map = format!("{uid} {uid} 1"); + let gid_map = format!("{gid} {gid} 1"); + // SAFETY: the child makes only async-signal-safe calls and leaves through + // `_exit`, never returning into Rust. + let pid = unsafe { libc::fork() }; + if pid == -1 { + return Err(format!( + "cannot check for Chromium's sandbox: {}", + io::Error::last_os_error() + )); + } + if pid == 0 { + // SAFETY: as above. + unsafe { libc::_exit(nest(&uid_map, &gid_map)) }; + } + let mut status = 0; + // SAFETY: `pid` is this process's child, and `status` outlives the call. + while unsafe { libc::waitpid(pid, &mut status, 0) } == -1 { + let err = io::Error::last_os_error(); + if err.kind() != io::ErrorKind::Interrupted { + return Err(format!("cannot check for Chromium's sandbox: {err}")); + } + } + let refused = match libc::WIFEXITED(status).then(|| libc::WEXITSTATUS(status)) { + Some(0) => return Ok(()), + Some(1) => "refuses to make a user namespace", + Some(2) => "refuses to map the studio's user into a user namespace", + Some(3) => "refuses to make a user namespace inside another", + _ => "crashed checking for user namespaces", + }; + Err(format!( + "Chromium sandboxes pages in user namespaces, and this system {refused}: allow them, as the README describes for browser sources on Linux" + )) +} + +/// Make a user namespace mapping the studio's user, and another inside it, +/// in a child about to exit. Returns 0, or the step that failed. +fn nest(uid_map: &str, gid_map: &str) -> i32 { + // SAFETY: plain system calls. + if unsafe { libc::unshare(libc::CLONE_NEWUSER) } != 0 { + return 1; + } + // An unprivileged user maps its group only once it gives up setgroups. + if !write(c"/proc/self/setgroups", b"deny") + || !write(c"/proc/self/gid_map", gid_map.as_bytes()) + || !write(c"/proc/self/uid_map", uid_map.as_bytes()) + { + return 2; + } + // SAFETY: as above. + if unsafe { libc::unshare(libc::CLONE_NEWUSER) } != 0 { + return 3; + } + 0 +} + +/// Write all of `data` to the file at `path`, without allocating. +fn write(path: &CStr, data: &[u8]) -> bool { + // SAFETY: `path` is a C string, and `data` outlives the calls. + unsafe { + let fd = libc::open(path.as_ptr(), libc::O_WRONLY | libc::O_CLOEXEC); + if fd < 0 { + return false; + } + let written = libc::write(fd, data.as_ptr().cast(), data.len()); + libc::close(fd); + written == data.len() as isize + } +} diff --git a/rs/moq-studio/tests/browser.rs b/rs/moq-studio/tests/browser.rs index 051b2516..3fbfb8cc 100644 --- a/rs/moq-studio/tests/browser.rs +++ b/rs/moq-studio/tests/browser.rs @@ -760,6 +760,82 @@ async fn a_crash_after_drawing_leaves_the_canvas() { .await; } +/// A page's renderer runs in Chromium's sandbox, so a page that exploits it +/// still cannot read a file of the studio's user, which the helper can. +#[tokio::test(flavor = "multi_thread")] +#[ignore = "needs CEF and a GPU; run by just render-sw, and on macOS by macos.yml"] +async fn a_renderer_cannot_read_the_user_s_files() { + local(async { + let dir = tempfile::tempdir().unwrap(); + let secret = std::fs::canonicalize(dir.path()).unwrap().join("stream-key"); + std::fs::write(&secret, "hunter2").unwrap(); + let red = page(""); + let mut studio = Studio::new(&[("page", red)]).await; + studio.until_center([255, 0, 0, 255], &[]).await; + + let helper = helper(std::process::id()).expect("the page's helper is running"); + assert!(can_read(helper, &secret), "the helper reads the user's files"); + let renderers = renderers(helper); + assert!(!renderers.is_empty(), "the page has a renderer"); + for renderer in renderers { + assert!( + !can_read(renderer, &secret), + "renderer {renderer} reads {}", + secret.display() + ); + } + }) + .await; +} + +/// Whether process `pid` can reach the file at `path`: whether it is there +/// under the process's root, looked through from `/proc`. Chromium's +/// namespace sandbox moves a renderer's root to the `fdinfo` directory of a +/// thread that has since exited, where every lookup finds no such process. +#[cfg(target_os = "linux")] +fn can_read(pid: u32, path: &Path) -> bool { + let under = Path::new("/proc") + .join(pid.to_string()) + .join("root") + .join(path.strip_prefix("/").unwrap()); + match std::fs::metadata(&under) { + Ok(_) => true, + Err(err) if err.kind() == std::io::ErrorKind::NotFound => false, + Err(err) if err.raw_os_error() == Some(rustix::io::Errno::SRCH.raw_os_error()) => false, + Err(err) => panic!("cannot look through {}: {err}", under.display()), + } +} + +/// Whether process `pid` may read the file at `path`, as its Seatbelt +/// sandbox, if any, decides. +#[cfg(target_os = "macos")] +fn can_read(pid: u32, path: &Path) -> bool { + use std::ffi::{CString, c_char, c_int}; + use std::os::unix::ffi::OsStrExt; + + unsafe extern "C" { + /// libsystem_sandbox's query of a process's sandbox: 0 if it allows + /// the operation, 1 if it denies it, -1 on failure. + fn sandbox_check(pid: c_int, operation: *const c_char, filter: c_int, ...) -> c_int; + } + const SANDBOX_FILTER_PATH: c_int = 1; + // Asked, not attempted, so nothing is logged as a violation. + const SANDBOX_CHECK_NO_REPORT: c_int = 0x4000_0000; + + let path = CString::new(path.as_os_str().as_bytes()).unwrap(); + // SAFETY: a path filter takes one C string, which outlives the call. + let denied = unsafe { + sandbox_check( + pid as c_int, + c"file-read-data".as_ptr(), + SANDBOX_FILTER_PATH | SANDBOX_CHECK_NO_REPORT, + path.as_ptr(), + ) + }; + assert!(denied >= 0, "cannot ask process {pid}'s sandbox"); + denied == 0 +} + /// Cookies, even one without an expiry, survive a reload of the page and a /// restart of the studio, since every page keeps them in one profile on disk. /// A second studio on the profile while it is in use fails its pages saying From 5cd34be6ebe5b747fe8c6e219b09b17f4012bc82 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Fri, 20 Nov 2026 17:38:08 -0800 Subject: [PATCH 3/4] chore(quest): follow up on nightly's failing macOS check Co-Authored-By: Claude Opus 5.5 --- quest/m0/nightly-macos-check.md | 29 +++++++++++++++++++++++++++++ 1 file changed, 29 insertions(+) create mode 100644 quest/m0/nightly-macos-check.md diff --git a/quest/m0/nightly-macos-check.md b/quest/m0/nightly-macos-check.md new file mode 100644 index 00000000..d2bbd118 --- /dev/null +++ b/quest/m0/nightly-macos-check.md @@ -0,0 +1,29 @@ +# [S] Nightly macOS check passes again + +## Goal + +The nightly workflow's macOS job, `just ci` on `macos-latest`, passes on +`main`, as it did on 2026-11-18. + +## Plan + +It has failed since 2026-11-19 +([run 44766089244](https://github.com/moq-dev/studio/actions/runs/44766089244)) +with two compile errors no Linux check sees: + +- `rs/moq-scene/src/browser/mach.rs:289`, a test: no method `id` on + `CFRetained`. Likely a feature of `objc2-io-surface` + (`IOSurfaceTypes`, which holds `IOSurfaceID`) that something else in the + graph used to turn on; find what changed in `Cargo.lock` between the two + runs and name the feature in `rs/moq-scene/Cargo.toml`. +- `rs/moq-studio/src/controls.rs`: `Fixed::id` and `Action::id` are dead code + on macOS, under `-D warnings`. Give them their macOS consumer, or gate them + on the platforms that read them. + +Fix on a Mac or by pushing and reading the nightly run +(`gh workflow run nightly.yml --ref `); a pull request runs no macOS +`just ci`. + +## Hosts + +- macos - the errors compile only there From d46d481f0e90127e8d856dbdc08653e6b8234971 Mon Sep 17 00:00:00 2001 From: Luke Curley Date: Fri, 20 Nov 2026 17:38:29 -0800 Subject: [PATCH 4/4] docs: say what browser sources on Linux need in one sentence Co-Authored-By: Claude Opus 5.5 --- README.md | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/README.md b/README.md index 7d18de63..a6bb335b 100644 --- a/README.md +++ b/README.md @@ -952,9 +952,9 @@ and nothing from a password field. On Linux, except for a page copied on the GPU through an X display, the text goes as plain text that the page's own copy handlers cannot change; on macOS the page copies as it would in a browser. -On Linux the sandbox needs unprivileged user namespaces, and the studio run as -a user other than root. Where the system refuses them, browser sources fail -saying so rather than render a page unsandboxed. Ubuntu refuses them, since +On Linux the sandbox needs unprivileged user namespaces, and a studio run by +a user other than root. Where either is missing, browser sources fail saying +so rather than render a page unsandboxed. Ubuntu refuses them, since 23.10, to any program an AppArmor profile does not allow; as root, allow the studio, naming the `moq-studio` you run: