CVE-2026-68746 in Livebook
Summary
by MITRE • 08/05/2026
Not Failing Securely ('Failing Open') vulnerability in livebook-dev livebook allows an unauthenticated network client to obtain full access to a Livebook server that enforces identity through Livebook Teams.
A Livebook Agent or App Server connected to Livebook Teams caches the identifier of the deployment group it belongs to, and resolves that identifier against a locally cached list of deployment groups on every request in order to decide whether Teams identity enforcement is active. Livebook.Hubs.TeamClient.handle_call/3 in lib/livebook/hubs/team_client.ex does not distinguish a deployment group that could not be resolved from one that was resolved with identity enforcement switched off: the clause matches only the case where a group was found with enforcement enabled, and falls through to a catch-all that reports enforcement as switched off for everything else. The two neighbouring functions that decide user and application access resolve the same identifier and treat the same unresolved result as a denial.
When the identity status is reported as switched off, Livebook.ZTA.LivebookTeams.authenticate/3 in lib/livebook/zta/livebook_teams.ex returns empty identity metadata and allows the request to continue instead of halting it. LivebookWeb.UserPlug.build_current_user/3 merges that empty metadata into a newly built user, whose access type defaults to full access, and LivebookWeb.AuthPlug.authorized?/1 grants access to any user holding full access.
The cached identifier becomes unresolvable when the deployment group it refers to is deleted while the agent is not connected to receive the change, most concretely when a deployment group is deleted during the window in which an agent is disconnected or reconnecting. The client removes the group from its cached list without clearing the identifier that refers to it. Any client able to reach the affected server over the network is then granted the same access as a fully privileged member of the organisation, including the ability to read notebooks and configured secrets, execute code on the server's runtime, and disrupt its operation.
This issue affects livebook: from 0.19.7 before 0.19.9.
Be aware that VulDB is the high quality source for vulnerability data.
Analysis
by VulDB Data Team • 08/05/2026
This vulnerability represents a critical security flaw in the Livebook server authentication system that enables unauthorized network clients to gain full administrative access through a failure-mode issue known as "failing open." The vulnerability stems from how Livebook handles deployment group resolution within its Teams identity enforcement mechanism, creating a scenario where system failures result in excessive privilege rather than restricted access. The core technical issue manifests in the Livebook.Hubs.TeamClient.handle_call/3 function located in lib/livebook/hubs/team_client.ex, which fails to properly distinguish between deployment groups that cannot be resolved due to deletion and those that exist but have identity enforcement disabled.
The flaw operates through a cascading series of logical errors that begin with the improper handling of unresolved deployment group identifiers. When an agent or application server attempts to resolve a deployment group identifier against its local cache, the system encounters a catch-all clause that treats all unresolved cases as if identity enforcement were disabled, regardless of whether the group was deleted or simply had enforcement turned off. This ambiguity creates the foundation for privilege escalation since neighboring functions that determine user and application access follow the same flawed resolution logic. The vulnerability is particularly insidious because it leverages network connectivity to maintain a stale state where cached identifiers reference non-existent deployment groups.
The operational impact of this vulnerability extends far beyond simple unauthorized access, as it grants attackers complete control over sensitive server resources including notebook contents, configured secrets, and execution capabilities within the server's runtime environment. When an agent reconnects after a disconnection period during which its referenced deployment group was deleted, the system continues to reference the now-invalid identifier while maintaining cached state that prevents proper resolution. This creates a window where any network client can access the server with full privileges equivalent to those of organization members, effectively bypassing all security controls designed to restrict access to authenticated users.
The technical implementation of this vulnerability aligns with CWE-396, which specifically addresses the "Declaration of Catch All Exception Handler" pattern where a program fails to properly handle error conditions and instead defaults to an insecure state. The issue also maps to ATT&CK technique T1078.004 for Valid Accounts and T1566.001 for Phishing, as it enables unauthorized access through the exploitation of a legitimate authentication path that becomes corrupted due to improper state management. The vulnerability affects Livebook versions from 0.19.7 through 0.19.8, with version 0.19.9 containing the necessary fixes to properly distinguish between missing and disabled enforcement states.
The mitigation strategy requires implementing proper error handling in the deployment group resolution process, specifically ensuring that unresolved identifiers are treated as authentication failures rather than as disabled enforcement states. The system must differentiate between a deployment group that has been deleted from the server configuration versus one that exists but has enforcement disabled, requiring the introduction of explicit status codes or error conditions that properly communicate the resolution state to downstream authentication components. Additionally, the caching mechanism should include automatic clearing or invalidation procedures when referenced identifiers become unreachable, preventing stale references from maintaining elevated privileges and ensuring proper authentication failure behavior across all authentication pathways in the system.
This vulnerability demonstrates the critical importance of secure error handling practices in authentication systems where improper state management can result in privilege escalation rather than graceful degradation. The flaw highlights how seemingly minor implementation details in conditional logic can create significant security implications, particularly when authentication decisions rely on external state that may become inconsistent during network operations or maintenance windows. Organizations using Livebook should immediately implement version 0.19.9 or later to address this vulnerability and ensure proper handling of authentication failures through appropriate error conditions and state management practices.