Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessAuthenticate as low-privilege user
-
DeliveryAccess custom integration endpoint calling install() directly
-
ExploitSupply blocked package name as untrusted input
-
ExecutionAllowlist coroutine silently skipped due to missing await
-
ImpactUnauthorized PyPI package installed into JupyterLab environment
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A01:2025 - Broken Access Control
ASVS 5.0
V8 - Authorization Access control enforcement
MITRE ATT&CK
1 technique across 1 tactic: Defense Evasion The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up. |
| Exploitation Conditions | Exploitation requires all four of the following conditions to be present simultaneously: (1) a custom extension or downstream integration must import PyPIExtensionManager and call install() directly with a package name derived from untrusted user input - the stock JupyterLab HTTP API handler and Extension Manager UI perform their own separate, correctly awaited check and are explicitly not affected; (2) an allowlist or blocklist must be actively configured with the intent of restricting which packages users may install; (3) the PyPI Extension Manager must be enabled, which is the default but can be replaced; and (4) kernels and terminals must be disabled or delegated to remote hosts, removing alternative package-installation vectors that would otherwise make this bypass redundant. PR:L in the CVSS vector confirms authenticated access is required. If any single condition is absent, this vulnerability carries no security consequence. |
| Impact | The CVSS 4.0 score of 7.7 with AV:N/AC:H/PR:L reflects a meaningful theoretical impact ceiling, but the SSVC assessment (Exploitation: none, Automatable: no, Technical Impact: partial) and an EPSS of 0.18% (8th percentile) together indicate that real-world exploitation is highly constrained and has not been observed. The AC:H rating accurately captures the four simultaneous non-default conditions required - a custom integration calling install() directly with untrusted input, a configured allowlist/blocklist, the PyPI Extension Manager enabled, and kernels/terminals disabled or remote. Absent any one of these, there is no security impact at all. The stock JupyterLab deployment is entirely unaffected, so even a standard institutional or organizational deployment faces no exposure from this flaw in its default configuration. This is a genuine defense-in-depth gap worth patching promptly, but it does not represent a broadly exploitable vulnerability warranting emergency response outside of the narrow affected deployment profile. No public exploit code exists and no KEV listing has been issued, consistent with the low EPSS signal. |
| Exploit ScenarioDerived | An authenticated user with low privileges gains access to a custom downstream integration or extension that calls PyPIExtensionManager.install() directly with user-supplied package names. Because the coroutine-based allowlist check silently fails to execute, a package name that the administrator intended to block is accepted and installed, potentially introducing malicious or unauthorized code into the JupyterLab environment. No public proof-of-concept code has been identified, and this scenario requires the attacker to operate within a non-default, specifically configured deployment with terminals and kernels disabled. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv2 – Aug 28, 2026
Allowlist/blocklist enforcement in JupyterLab's PyPIExtensionManager.install() was silently bypassed due to a missing 'await' on the is_install_allowed coroutine, allowing authenticated low-privilege users to install otherwise-blocked PyPI packages in narrowly configured deployments. Affected are JupyterLab >=4.6.0 <=4.6.1 and <=4.5.9; the stock HTTP API and Extension Manager UI are explicitly not affected because they perform their own independently awaited check. No active exploitation has been identified - CISA KEV is absent, EPSS sits at 0.18% (8th percentile), and SSVC rates exploitation as none with non-automatable impact.
Earlier versions of this analysis (1)
Allowlist/blocklist bypass in JupyterLab's PyPIExtensionManager.install() allows unauthorized pip packages to be installed when a custom extension or downstream integration calls install() directly with untrusted input - a missing 'await' on the is_install_allowed coroutine caused the async check body to never execute, silently emitting only a RuntimeWarning. The stock JupyterLab HTTP API and Extension Manager UI are not affected; the gap is limited to non-standard programmatic callers of the public install() method. No public exploit exists; vendor-released patches are available in JupyterLab 4.6.2 and 4.5.10.
RemediationAI
Upgrade to JupyterLab 4.6.2 (for 4.6.x deployments) or 4.5.10 (for 4.5.x deployments) as confirmed by the vendor advisory at https://github.com/jupyterlab/jupyterlab/security/advisories/GHSA-whvh-wf3x-g77j; patch commits are tracked in pull requests https://github.com/jupyterlab/jupyterlab/pull/19184 and https://github.com/jupyterlab/jupyterlab/pull/19185. Users of downstream applications such as Notebook v7+ must explicitly upgrade the jupyterlab pip package as well. For deployments that cannot immediately patch, a complete workaround is to switch to the read-only extension manager using the CLI flag '--LabApp.extension_manager=readonly' or the traitlet 'c.LabApp.extension_manager = readonly'; this disables all programmatic extension installation but also prevents legitimate users from adding extensions through any interface. No action is required for deployments that exclusively expose extension management through the standard JupyterLab HTTP API or Extension Manager UI, as those paths were unaffected.
Affected VersionsENISA
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 1 package in pypi
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
JupyterLab uses an async Python architecture where extension installation is managed by PyPIExtensionManager. The install() method was intended to self-enforce the configured allowlist/blocklist by calling the is_install_allowed coroutine, but the missing 'await' keyword caused Python to create a coroutine object without executing it, emitting only a RuntimeWarning. This is a CWE-284 (Improper Access Control) defect rooted in Python async/await semantics - the control check appeared present in code but was never actually invoked at runtime. The CPE cpe:2.3:a:jupyterlab:jupyterlab covers the affected pip package. Because the HTTP API handler independently invokes its own correctly awaited check before calling install(), the gap existed only in the install() method itself as a secondary defense-in-depth layer, not in the primary access path.
Know when Jupyterlab gets its next vulnerability
- Watch products and get an email when something new is published
- Check this CVE against your own stack and servers
- Exploit and PoC references, threat intelligence from 22 sources
No credit card · 7-day full trial
Severity by source
Sources disagree (Low–High)CVSS:4.0/AV:N/AC:H/AT:N/PR:L/UI:N/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N
Network vector with high complexity due to four required non-default conditions; PR:L confirms authenticated access; full CIA impact if arbitrary package installation achieves code execution.
vuln.today treats the vendor’s rating as authoritative. A higher third-party CVSS (e.g. CISA-ADP) is shown for transparency but does not drive the headline severity.
CVSS VectorVendor: VulnCheck
Lifecycle Timeline
3DescriptionCVE.org
JupyterLab versions >=4.6.0,<=4.6.1 and <=4.5.9 contain an allowlist/blocklist enforcement gap in PyPIExtensionManager.install(). A missing 'await' caused the is_install_allowed coroutine to never execute, so the extension allowlist/blocklist check was not enforced for direct callers of install(). The stock JupyterLab HTTP API and Extension Manager UI are not affected, as they perform a separate, correctly awaited check. The issue affects only deployments where a custom extension or downstream integration imports PyPIExtensionManager and calls install() directly with a package name influenced by untrusted input, an allowlist/blocklist is configured, the PyPI Extension Manager is enabled, and kernels and terminals are disabled or delegated to remote hosts. Fixed in JupyterLab 4.6.2 and 4.5.10.
Blast Radius
ecosystem impact- 5 pypi packages depend on jupyterlab (2 direct, 3 indirect)
Ecosystem-wide dependent count for version 4.6.0.
Executive ViewAI
JupyterLab versions through 4.5.9 and 4.6.0-4.6.1 contain a vulnerability allowing authenticated users to bypass package installation restrictions in narrowly-configured deployments, potentially enabling unauthorized installation of malicious Python packages and code execution. The vulnerability affects only specific deployment configurations where allowlist or blocklist controls are explicitly enforced; standard deployments using the Extension Manager UI or HTTP API remain unaffected. Organizations should identify and patch affected JupyterLab instances to maintain package governance controls.
Apply vendor patch.
Threat Intelligence Overview
How this decision was reached
The engine reads each signal below and applies a fixed list of rules from top to bottom. The first rule that matches sets the recommended action – like a statement, every line is shown.
What every action level means
SSVC AssessmentENISA
Attack Technique
Authentication bypass attacks exploit flaws in the verification mechanisms that control access to systems and applications.
More in Jupyterlab
View allJupyterLab extension template is a `copier` template for JupyterLab extensions. Rated critical severity (CVSS 9.8), this
JupyterLab is a user interface for Project Jupyter which will eventually replace the classic Jupyter Notebook. Rated cri
JupyterLab is an extensible environment for interactive and reproducible computing, based on the Jupyter Notebook and Ar
jupyterlab is an extensible environment for interactive and reproducible computing, based on the Jupyter Notebook Archit
JupyterLab is an extensible environment for interactive and reproducible computing, based on the Jupyter Notebook and Ar
Plugin lock-rule enforcement bypass in JupyterLab (pip package, versions >=4.1.0,<=4.5.9 and >=4.6.0,<=4.6.1) allows aut
Argument injection in JupyterLab's PyPI Extension Manager (JupyterLab 4.0.0 through 4.5.10 and the 4.6.x branch before 4
Stored cross-site scripting in JupyterLab's Extension Manager allows an attacker who publishes a malicious PyPI package
Improper trust attribution in JupyterLab's markdownviewer:trust and notebook:trust command-link handlers lets a Trust de
jupyterlab is an extensible environment for interactive and reproducible computing, based on the Jupyter Notebook Archit
Same weakness CWE-284 – Improper Access Control
View allSame technique Authentication Bypass
View allVendor StatusVendor
SUSE
Severity: Important| Product | Status |
|---|---|
| openSUSE Tumbleweed | Fixed |
EUVD-2026-57795
GHSA-r336-hqvq-mfjh
NVD
CVE.org
EPSS
Vulnrichment
Exploit-DB