Skip to content

bug: browser: CEF 7871 (Chromium 150.0.7871.252, end of life, two in-the-wild V8 CVEs) runs with no_sandbox on every platform #1092

Closed

Description

@rdoupe

Summary: every obs-rust build with the browser plugin ships CEF 7871, which is Chromium 150.0.7871.252. obs-browser starts it with settings.no_sandbox = true on every platform. Chromium 150 gets no more security fixes: its last extended-stable update was 150.0.7871.250 on 2026-08-18. Since then Chrome has fixed two V8 bugs that were exploited in the wild, CVE-2026-85046 and CVE-2026-87491, and both are in CISA KEV. With the sandbox off, a renderer exploit in any page a Browser Source or dock loads runs as the OBS user, with no sandbox escape needed.

Affected versions: obs-rust/obs-studio <= 0.1.0-beta.20261014.

  • Windows x64/arm64, macOS arm64/x86_64 and the Linux .deb. CMakePresets.json pins cef 7871 from the obs-rust/cef mirror, which holds byte-for-byte copies of the archives upstream OBS uses. cef_version.h in the Linux x86_64 archive reads 150.0.19+gcf60f42+chromium-150.0.7871.252. The release .deb ships libcef.so (Chrome/150.0.7871.252), obs-browser-page and obs-browser.so, because the Ubuntu CI build sets -DENABLE_BROWSER=ON.
  • Linux AppImage: not affected. It builds with -DENABLE_BROWSER=OFF, which is still true on master after appimage: Build on a glibc 2.28 base and stop bundling glibc #927.
  • no_sandbox: set in obs-browser submodule 1e313ae, obs-browser-plugin.cpp:296, with no platform #if.

Verified advisories:

ID Component Severity Fixed in Exploited Affects 150.0.7871.252
CVE-2026-85046 V8 type confusion High (Chromium), 8.8 (NVD) 152.0.7977.82 (2026-09-03) yes: Chrome Releases ("exploit ... exists in the wild"), CISA KEV 2026-09-04 yes (the 150 branch had ended; extended stable moved to 152 on 2026-09-09)
CVE-2026-87491 V8 out-of-bounds write Medium (Chromium), 8.8 (NVD) 153.0.8010.36 (2026-09-08) yes: Chrome Releases, CISA KEV 2026-09-09 yes

NVD also lists about 1,250 more Chromium CVEs with a fix version above 150.0.7871.250, 41 of them Critical. Some may have been backported into the CEF 150 maintenance build, so treat that count as an upper bound. Chrome stable is now 155.0.8059.84; extended stable is 152.0.7977.169.

Impact on OBS: Browser Sources and browser docks run remote pages (alert overlays, chat widgets, third-party widget sites) for hours inside OBS. Any of these is enough to reach V8:

  • a compromised widget provider;
  • an injected ad;
  • a malicious URL pasted in as a browser source.

With no_sandbox, code execution in the renderer is code execution as the user. That exposes files, stream keys and the OBS websocket password in the profile.

CVSS 3.1: AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H = 8.8, for Windows, macOS and .deb users with any remote browser source or dock.

Suggested fix:

  1. Move to a supported CEF branch: 7977 (Chromium 152, current extended stable) or 8059 (Chromium 155). Build or mirror it into obs-rust/cef, update CMakePresets.json dependencies.cef (version and hashes), and fix any obs-browser API breakage. This needs a CEF build and mirror; nothing has been prepared yet.
  2. The structural fix is to re-enable the CEF sandbox wherever the platform allows it:
    • Windows: link obs-browser-page.exe with cef_sandbox.
    • macOS: give the helper app the sandbox entitlement.
    • Linux: set up the chrome-sandbox helper or a namespace sandbox.
      This is a larger change and a behaviour change, so it needs a design decision.
  3. Add a CI check that fails when the pinned CEF's Chromium major is older than the current extended-stable major.

What I tested: no exploit code and no crafted pages.

  • Read include/cef_version.h from the obs-rust/cef 7871 Linux archive.
  • Read the version string from libcef.so in the release .deb.
  • Read no_sandbox from the pinned obs-browser commit, and the build flags from obs-rust master (.github/scripts/.build.zsh, build-aux/appimage/build.py).
  • Checked the CVEs against NVD, including the CISA KEV fields.
  • Checked the Chrome Releases blog feed (stable and extended-stable posts, June to October 2026) for the branch end date and the in-the-wild statements.

Activity

  1. vpacher commented on Oct 17, 2026

    @vpacher
    Member

    Linux sandbox: measurements for the design decision

    I measured what settings.no_sandbox = false does on Linux before proposing a design. I claim the Linux part of the sandbox work (one PR per platform; Linux first, then macOS, then Windows). The CEF upgrade itself (item 1) needs the obs-rust/cef mirror, so I leave it to you.

    Setup: obs-rust master f8616875c, -DENABLE_BROWSER=ON, CEF 7871 from obs-rust/cef (cef_version.h: 150.0.19+gcf60f42+chromium-150.0.7871.252, archive hash matches CMakePresets.json). Debian 13 in an unprivileged Proxmox LXC container, kernel 7.0.14, kernel.unprivileged_userns_clone = 1, apparmor_restrict_unprivileged_userns = 0. A test OBS on Xvfb with its own HOME and websocket port; a Browser Source loads a page whose JavaScript sets a colour, read back through GetSourceScreenshot. "Sandboxed" means the renderer has its own user and PID namespace and Chromium's seccomp-bpf filter (Seccomp_filters: 2: LXC's plus Chromium's).

    no_sandbox OBS runs as user namespaces result
    true (today) root available renders; every CEF process has --no-sandbox
    false root available OBS exits: content::ZygoteHostImpl::Init (zygote_host_impl_linux.cc:104) calls exit() because Chromium does not run sandboxed as root. CEF runs in the OBS process, so exit() ends OBS, and a joinable std::thread turns it into std::terminate/abort
    false normal user available renders, sandboxed: renderers and one of the two utility processes have their own user + PID namespace and seccomp-bpf; the GPU process, the other utility process and the first zygote do not (normal for Chromium on Linux). No setuid helper needed
    false normal user blocked (systemd RestrictNamespaces=~user, same effect as Ubuntu 24.04+'s AppArmor restriction) OBS dies: FATAL:setuid_sandbox_host.cc:166] The SUID sandbox helper binary was found, but is not configured correctly. Rather than run without sandboxing I'm aborting now.

    Findings:

    1. Setting no_sandbox = false alone crashes OBS in two common setups (OBS as root; no unprivileged user namespaces). obs-browser must decide before CefInitialize whether a sandbox can work.
    2. The .deb and the build already install chrome-sandbox next to libcef.so, but with normal permissions (install(FILES ...)), so it is never setuid. A non-setuid helper is worse than none: Chromium aborts when it finds one that is not configured, instead of falling back.
    3. Upstream: obsproject/obs-browser master still sets settings.no_sandbox = true, and OBS 33.0.0-rc2 ships the same CEF 7871. Nothing to take over from upstream here.

    Proposal (decisions for you):

    A. Pre-check before CefInitialize (always): no sandbox when euid is 0; otherwise a sandbox when a child process can create a user + PID namespace (an actual clone/unshare probe; sysctls alone miss AppArmor and seccomp restrictions), or when chrome-sandbox next to libcef.so is root-owned with mode 4755. The decision logic is a pure function over the probe results, so it gets a Tier 1 RED → GREEN test; the probes live behind the platform boundary.

    B. When no sandbox is possible:

    1. fail-open: run as today (no_sandbox = true), with a log line that says why (root, no user namespaces) and a notice in the UI. My default proposal.
    2. fail-closed: Browser Sources and docks stay off, with a notice.
    3. a setting ("Require the browser sandbox") that turns 1 into 2.

    I propose 1 as the default plus 3, so that nobody loses their overlays after an update, and people who want the guarantee can have it.

    C. Packaging (.deb):

    1. stop installing a non-setuid chrome-sandbox (finding 2), and ship an AppArmor profile for obs-browser-page that allows user namespaces (as Chrome's package does for Ubuntu 24.04+). My proposal.
    2. or install chrome-sandbox setuid root from the package's postinst.

    Flatpak needs its own mechanism (zypak / flatpak-spawn) and the AppImage builds without the browser, so both stay out of the Linux PR.

    D. OBS as root always gets the fallback from B, with the reason in the log.

    If you agree with A + B1/B3 + C1 (or tell me otherwise), I'll start with the pre-check and the fallback in obs-browser, then the packaging change. I can test the sandboxed and the fallback paths here (Debian 13, LXC with and without user namespaces); Ubuntu 24.04's AppArmor path I can test in a separate container.

  2. vpacher commented on Oct 22, 2026

    @vpacher
    Member

    Claiming: #1092 (Linux sandbox part, as in my comment above)

    @zackees, could you decide the design points from the measurement comment?

    • A: a pre-check before CefInitialize.
    • B: when no sandbox is possible, fail open with a log line and a UI notice, plus a "Require the browser sandbox" setting.
    • C: in the .deb, drop the non-setuid chrome-sandbox and add an AppArmor profile for obs-browser-page.
    • D: OBS running as root always uses the fallback from B.

    I am starting with A now, because every option needs it: the decision as a pure function, with a failing test first, in obs-rust/obs-browser. B and C wait for your answer.

  3. added
    claimedAn agent or person has claimed this; check the claim comment before starting
    on Oct 22, 2026
  4. vpacher commented on Oct 22, 2026

    @vpacher
    Member

    Correction to C1 in my measurement comment, after a test on Ubuntu 24.04 (details in the draft PR obs-rust/obs-browser#3):

    An AppArmor profile with userns for obs-browser-page is not enough. Chromium still aborts ("No usable sandbox!"). The user namespaces are created by the process that hosts CEF, so the profile has to cover the OBS executable. With the profile on the main binary, the sandbox works.

    Test setup: Ubuntu 24.04.5, kernel 6.8, kernel.apparmor_restrict_unprivileged_userns = 1. A minimal CEF 7871 host with a separate subprocess binary, as obs-browser uses. The probe from #3 agrees with Chromium in all five cases I ran: stock with a chrome-sandbox that is not setuid, stock without chrome-sandbox, no_sandbox, a profile on the subprocess only, and a profile on the main binary. Without such a profile, the probe gives "off", so the .deb keeps working as today on Ubuntu 24.04.

    So C1 becomes: in the .deb, drop the chrome-sandbox that is not setuid, and ship an AppArmor profile for the OBS executable that allows userns.

  5. zackees commented on Oct 23, 2026

    @zackees
    Member

    The CEF upgrade (item 1 here) is now tracked on its own in #1864. The browser source in the AppImage (#1865) waits on #1864 and on the Linux sandbox work here.

  6. vpacher commented on Oct 24, 2026

    @vpacher
    Member

    The CEF 8078 rerun from my comment in #1864 is done: obs-rust/obs-browser#3 gives the same results on 8078 as on 7871, in the container matrix and in all five Ubuntu 24.04 AppArmor cases (details in the PR description). No code change was necessary.

    #1865 (the browser source in the AppImage) now waits only on the fallback policy here.

    Decision needed: @zackees, could you decide B and D from my comment above?

    • B: when no sandbox can work, fail open with a log line and a UI notice, plus a "Require the browser sandbox" setting (default off).
    • D: OBS that runs as root always uses the fallback from B.

    #3 stays a draft until then. If you agree with these defaults, I will mark #3 ready and do B in a follow-up PR.

  7. vpacher commented on Oct 24, 2026

    @vpacher
    Member

    Decision needed: B and D of the Linux sandbox fallback, as in my comment above (#1092 (comment)). obs-rust/obs-browser#3 stays a draft until then, and #1865 waits on it.

    I repeat the question here so that the new decision-needed label (#2069) picks it up. The earlier comment was posted before #2069 merged.

  8. zackees commented on Oct 24, 2026

    @zackees
    Member

    Coordinator: I'm escalating this one to human-review-needed instead of deciding it. B and D set the default security posture of the browser sandbox, which is a security design choice, and the coordinator leaves those to the maintainer.

    For what it's worth, my recommendation is to accept both as proposed. Today the sandbox is off everywhere, so a fail-open fallback with a log line, a UI notice and an opt-in "Require the browser sandbox" setting is a strict improvement. It also keeps Browser Sources working on systems where no sandbox can start, and those users would otherwise lose them. D follows from the same logic, since Chromium can't sandbox as root anyway.

  9. added
    human-review-neededEscalated: waits on the human maintainer
    and removed
    decision-neededAn open question for the maintainer
    on Oct 24, 2026
  10. zackees commented on Oct 24, 2026

    @zackees
    Member

    Decision:

    warn user with 3 second progress countdown to auto accept "Accept anyway"

    log the error to stderr stream

    make this a policy for similar issues in the future and warn the user this may be become a hard error in the future.

    use terminology that is standard for this and don't fear rewriting the warning prompt for similar warnings/errors

  11. zackees commented on Oct 24, 2026

    @zackees
    Member

    Decided: accepted as proposed, with a warning that auto-accepts after a countdown.

    • Warn the user with a 3-second progress countdown that auto-accepts "Accept anyway".
    • Log the error to the stderr stream.
    • Make this the policy for similar issues in the future, and warn the user that this may become a hard error in the future.
    • Use terminology that is standard for this, and do not fear rewriting the warning prompt for similar warnings/errors.

    Verbatim from the maintainer's decision comment above (2026-10-24T20:11:13Z). This comment repeats it starting with Decided: because the claim bot only recognises that spelling: the wording of the original ("Decision: …") matches neither its Decision needed: nor its Decided: pattern, so the decision was invisible to it.

    @vpacher — this lifts the block on the Linux fallback work: obs-rust/obs-browser#3 can come out of draft, and #1865 (browser source in the AppImage) can proceed once it lands. claim-blocked clears on your next comment here.

    human-review-needed has been removed by hand: the claim bot has no command that clears it, and none of its sweeps touch it, so the escalation would otherwise sit in the maintainer queue forever. Tracked in #2212.

  12. 17 remaining items

  13. vpacher commented on Oct 25, 2026

    @vpacher
    Member

    Claiming: #1092 (macOS sandbox part). The Linux part is done.

    Linux, done: browser sources and panels use the CEF sandbox where it can work (user namespaces, or a setuid-root chrome-sandbox), and where it can't, OBS logs the error and shows the shared fallback warning with the cause and what to change, as decided above.

    macOS, next (this claim): measure first, as for Linux, then one PR in obs-browser.

    1. Check what the macOS CEF archive brings for the sandbox (cef_sandbox, the helper bootstrap) and what the four helper bundles (OBS Helper, GPU, Plugin, Renderer) need: the sandbox context in the helper main() before the framework loads, and the entitlements in cmake/macos/.
    2. Measure no_sandbox = false on macOS (Apple Silicon and Intel; signed and unsigned builds): which pages render, what the helpers' sandbox state is, and where it can't work.
    3. RED/GREEN in obs-browser: the decision for macOS in browser-sandbox (today macOS has no probe and stays off), and the same fallback warning where the sandbox can't work.

    Moved out of this issue: the CEF version (item 1) is #1864. The Windows sandbox (item 2) is #2379 and the CEF age check in CI (item 3) is #2380, so they can be claimed on their own. This issue then closes with the macOS PR.

  14. vpacher commented on Oct 25, 2026

    @vpacher
    Member

    Done: the macOS part is in master with #2402 (6a7ef1742), the bump to obs-rust/obs-browser 63fd678.

    macOS: each helper sandboxes itself (Seatbelt) with libcef_sandbox.dylib from the CEF framework in the app (obs-rust/obs-browser#12). Without the library, the helpers run without the sandbox, and OBS logs the error and shows the shared fallback warning, as on Linux.

    Measured on macOS 26.7.1, Apple Silicon, CEF 7871, ad-hoc signed local build, with a page that turns green only if HTTPS fetch, WebAudio, and WebM recording and playback all work:

    • with the library: all six helpers sandboxed (the GPU process, three utility processes, two renderers), the page green;
    • without the library: the fallback warning, the helpers without the sandbox, the page green.

    The helpers needed no extra entitlements for this.

    Not tested:

    Linux: done earlier (obs-rust/obs-browser#3 and #8, #2238, #2378).

    Elsewhere: the Windows sandbox is #2379 (maintainer decision on bootstrap.exe), the CEF version is #1864, and the CEF age check in CI is #2380. With those tracked there, this issue can close.

  15. moved this from In progress to Ready in obs-rust Multiviewon Oct 26, 2026
  16. zackees commented on Oct 31, 2026

    @zackees
    Member

    Closing: every part of this report has landed or been split into its own tracked issue, so this one no longer has work of its own.

    docs/features.md:273 already documents the sandbox state per platform. Reopen this issue only if the Windows decision is revisited.

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Metadata

Metadata

Assignees

No one assigned

    Labels

    readyMeets the definition of Ready; claimable

    Type

    No type

    Projects

    Milestone

    No milestone

    Relationships

    None yet

    Development

    No branches or pull requests

    Issue actions