Skip to main content

JupyterLab CVE-2026-42266

HIGH
Improper Input Validation (CWE-20)
2026-05-05 https://github.com/jupyterlab/jupyterlab GHSA-37w4-hwhx-4rc4
8.8
CVSS 3.1 · Vendor: https://github.com/jupyterlab/jupyterlab
View

Attack ChainAIDerived

Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain

  1. Recon
    Authenticate to JupyterLab
  2. Delivery
    Access Extension Manager API
  3. Exploit
    Craft POST request with malicious PyPI package
  4. Install
    Bypass allow-list validation
  5. C2
    Install arbitrary extension
  6. Execute
    Execute malicious code in server context
  7. Impact
    Exfiltrate data or establish persistence

Vulnerability Assessment

Weakness
CWE
OWASP Top 10:2025
A05:2025 - Injection
ASVS 5.0
V2 - Validation and Business Logic Input validation, allowlisting
Exploitation Conditions

Exploitation requires four specific conditions: (1) PyPI Extension Manager must be enabled (this is the default configuration in JupyterLab), (2) the deployment must use an extension allow-list via allowed_extensions_uris configuration (vulnerability only manifests when admins attempt to restrict extensions), (3) attacker must possess valid authenticated user credentials (PR:L indicates low-privilege user access suffices), and (4) deployment must be multi-tenant or shared (single-user deployments see reduced impact as users already have equivalent package installation capabilities). Exploitation is NOT possible if: extension manager is configured in read-only mode, JupyterLab is running in single-user mode where the user already has direct pip install access, or the deployment does not use allow-list restrictions (though this represents insecure configuration). The CVSS vector AV:N/AC:L/PR:L/UI:N confirms network accessibility with low complexity and no user interaction required beyond initial authentication.

Impact

This vulnerability presents high real-world risk in specific deployment contexts despite moderate CVSS score nuances. The CVSS vector (AV:N/AC:L/PR:L/UI:N) indicates network-accessible exploitation requiring only low-privilege authentication with no user interaction, yielding high impact across confidentiality, integrity, and availability (C:H/I:H/A:H). However, real-world risk is highly context-dependent: deployments using default configurations with PyPI Extension Manager enabled and multi-tenant access models face immediate exposure, while single-user or properly isolated deployments see reduced impact. No public exploit identified at time of analysis and not listed in CISA KEV, suggesting exploitation has not yet become widespread. The attack complexity is objectively low (direct POST request to install extensions), making this highly automatable once an attacker gains authenticated access. Priority assessment depends on deployment model: CRITICAL for shared JupyterHub educational environments and multi-tenant SaaS offerings where students or untrusted users have authenticated access; MEDIUM for single-user research deployments. The vendor's explicit mention of data exfiltration, lateral movement, and persistent compromise scenarios indicates this enables full environment takeover in vulnerable configurations.

Exploit ScenarioDerived

An authenticated student in a university JupyterHub environment or a low-privilege user in a multi-tenant JupyterLab deployment crafts a direct POST request to the JupyterLab extension manager API endpoint, requesting installation of a malicious Python package from PyPI that is not on the administrator-configured allow-list. The server fails to validate the request against allowed_extensions_uris, installs the malicious package, and grants the attacker arbitrary code execution within the JupyterLab server context. The attacker leverages this access to exfiltrate sensitive data from other users' notebooks, establish persistence through scheduled tasks, and pivot to adjacent network resources accessible from the server.

This Week Schedule remediation this week. Why: HIGH severity (CVSS 7.0-8.9).
Patch available 0.1% exploitation probability (EPSS)

Get an e-mail when this CVE is exploited, patched or re-scored. Free account.

Alert me

AnalysisAIv1 – May 05, 2026

Privilege escalation in JupyterLab 4.0.0 through 4.5.6 allows authenticated users to bypass extension allow-list controls and install arbitrary PyPI packages, enabling potential data exfiltration and lateral movement in multi-tenant deployments. The PyPI Extension Manager failed to enforce the allowed_extensions_uris configuration, permitting installation of packages outside the approved list. This vulnerability is particularly critical in shared educational environments (JupyterHub) and multi-tenant deployments where kernel/terminal access is restricted. Vendor-released patch available in JupyterLab v4.5.7. No public exploit identified at time of analysis, though exploitation requires only authenticated access with low complexity (CVSS AC:L).

RemediationAI

Upgrade JupyterLab to version 4.5.7 or later, which contains the validated patch for this vulnerability (release details at https://github.com/jupyterlab/jupyterlab/releases/tag/v4.5.7). For deployments using applications that bundle JupyterLab such as Jupyter Notebook v7+, ensure the underlying jupyterlab package dependency is also updated to 4.5.7 or later. If immediate patching is not feasible, implement the workaround by switching to read-only extension manager mode using either command-line option --LabApp.extension_manager=readonly or configuration traitlet c.LabApp.extension_manager = 'readonly' in your JupyterLab configuration file. Trade-off: this workaround completely disables extension installation capabilities for all users, including administrators, which may impact legitimate workflow requirements. Verify read-only mode is active through the GUI (settings icon should display lock indication). Note that configuring a PyPI proxy with allow-listed packages is explicitly NOT sufficient to mitigate this vulnerability due to the server-side validation bypass. For multi-tenant deployments, review and apply security hardening guidance from https://jupyterhub.readthedocs.io/en/5.2.1/explanation/websecurity.html.

Affected Packages

pypi jupyterlab fix: 4.5.7

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 is a web-based interactive development environment for Jupyter notebooks, code, and data. The PyPI Extension Manager is a built-in GUI feature that allows users to discover and install Python extensions from the Python Package Index (PyPI). This vulnerability (CWE-20: Improper Input Validation) stems from insufficient enforcement of the allowed_extensions_uris configuration parameter, which administrators use to restrict installable extensions to a specific allow-list. The flaw exists in the server-side validation logic that processes extension installation requests, failing to properly validate that requested packages match the configured URI allow-list. This creates a policy discrepancy between the intended administrative controls and actual enforcement, effectively bypassing the security boundary meant to separate user capabilities from package installation privileges. Affected package identified via CPE: pkg:pip/jupyterlab versions 4.0.0 through 4.5.6.

Know when Python 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

Vendor (https://github.com/jupyterlab/jupyterlab) PRIMARY 8.8 HIGH
AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H
Red Hat 8.8 HIGH

Primary rating from Vendor (https://github.com/jupyterlab/jupyterlab).

CVSS VectorVendor: https://github.com/jupyterlab/jupyterlab

Attack Vector
Network
Attack Complexity
Low
Privileges Required
Low
User Interaction
None
Scope
Unchanged
Confidentiality
High
Integrity
High
Availability
High

DescriptionCVE.org

The allow-list of extensions that can be installed from PyPI Extension Manager (allowed_extensions_uris) is not correctly enforced by JupyterLab prior to 4.5.X. The PyPI Extension Manager was not contained to packages listed on the default PyPI index.

This has security implications for deployments that:

  • have allow-listed specific extensions with aim to prevent users from installing packages
  • have the kernel and terminals disabled or delegated to remote hosts (thus no access to install packages in the single-user server environment)
  • have multi-tenant deployments that is not configured for untrusted users (as per documented on JupyterHub https://jupyterhub.readthedocs.io/en/5.2.1/explanation/websecurity.html)
  • have the (default) PyPI Extension Manger enabled

Impact

An authenticated attacker - such as a student in a shared JupyterHub environment or a user in a multi-tenant JupyterLab deployment - can escalate their privileges. This might allow for data exfiltration, lateral movement within the network, and persistent compromise of the server infrastructure.

Patches

JupyterLab v4.5.7 contains the patch.

Users of applications that depend on JupyterLab, such as Notebook v7+, should update jupyterlab package too.

Workarounds

Switch to read-only extension manager by adding the following command line option:

bash
--LabApp.extension_manager=readonly

or the following traitlet:

python
c.LabApp.extension_manager = 'readonly'

You can confirm that the read-only manager is in use from GUI:

<img width="293" height="293" alt="image" src="https://github.com/user-attachments/assets/8016c809-633e-4ed0-a5bc-6bc4793caa0f" />

Note: configuration of a PyPI proxy with allow-listed packages is not sufficient to protect from this vulnerability.

Resources

  • allow-list https://jupyterlab.readthedocs.io/en/stable/user/extensions.html#listing-configuration
  • https://jupyterhub.readthedocs.io/en/5.2.1/explanation/websecurity.html
  • https://jupyterlab.readthedocs.io/en/latest/user/extensions.html#extension-manager-implementations

Executive ViewAI

Why It Matters

JupyterLab versions 4.0.0 through 4.5.6 contain a privilege escalation vulnerability allowing authenticated users to install unauthorized packages, bypassing security controls designed to restrict software dependencies in shared environments. Organizations operating JupyterHub or multi-tenant Jupyter deployments face elevated risk of data exfiltration and lateral movement, as users can execute arbitrary code within kernel environments that administrators believed were restricted.

Business Impact: High
Compensating Controls

Pending vendor patch availability, implement network-level restrictions: (1) restrict PyPI repository access at firewall/proxy layer to approved package indices only; (2) disable or restrict the PyPI Extension Manager feature in JupyterLab configuration if not required for operations; (3) enforce strict role-based access controls limiting extension installation privileges to administrators only; (4) monitor PyPI package installation attempts and alert on out-of-policy packages; (5) isolate multi-tenant Jupyter deployments using separate virtual environments or containers with restricted external network access. Apply vendor patch (JupyterLab v4.5.7) immediately upon release.

Threat Intelligence Overview

EPSS Score
0.1%
Top 81% exploitable
Threat Intel
1
1 source
Data Quality
6 sources
Confidence: High
NVD CVE.org EPSS GHSA Vendor GitHub VulDB

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.

SignalValue
Severity HIGH
CISA KEV No
Public POC No
EPSS 0.1%
Patch available Yes
Active threat No
Deciding rule
HIGH severity (CVSS 7.0-8.9)
What every action level means
Emergency Immediate action required. Criteria: CRITICAL + in CISA KEV (actively exploited) without patch, OR CRITICAL + EPSS > 30% without patch, OR CRITICAL + active threat signals without patch.
Act Now Prioritize within 24-48h. Criteria: in KEV with patch available, OR CRITICAL + public POC, OR HIGH + EPSS > 10%, OR CRITICAL + active threat, OR any CRITICAL severity.
This Week Schedule remediation this week. Criteria: HIGH severity (CVSS 7.0-8.9). Patch within normal change window.
This Month Plan within 30 days. Criteria: MEDIUM severity (CVSS 4.0-6.9), lower exploitation probability. Include in regular patch cycle.
Monitor Track and reassess. Criteria: LOW severity (CVSS 0.1-3.9), minimal exploitation risk. No immediate action needed.

SSVC AssessmentENISA

SSVC Decision· derived
Scheduled
Exploitation· derived
None
System Exposure· derived
Open
Automatable· derived
No
Human Impact
High

Priority Score

44
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +44
PoC: 0
Weaponized: 0
Threat intel: 0
Gov advisory: 0

Attack Technique

Privilege escalation occurs when an attacker leverages flaws in access control mechanisms to gain permissions beyond what they were originally granted.

Affected Products (CPE)CVE.org

pkg:pip/jupyterlab

More in Python

View all
CVE-2025-24016 CRITICAL POC
9.9 Feb 10

Wazuh SIEM platform versions 4.4.0 through 4.9.0 contain an unsafe deserialization vulnerability in the DistributedAPI t

CVE-2025-27520 CRITICAL POC
9.8 Apr 04

BentoML version 1.4.2 and earlier contains an unauthenticated remote code execution vulnerability through insecure deser

CVE-2025-2945 CRITICAL POC
9.9 Apr 03

pgAdmin 4 contains critical remote code execution vulnerabilities in the Query Tool download and Cloud Deployment endpoi

CVE-2013-5093 MEDIUM POC
6.8 Sep 27

The renderLocalView function in render/views.py in graphite-web in Graphite 0.9.5 through 0.9.10 uses the pickle Python

CVE-2025-32375 CRITICAL POC
9.8 Apr 09

BentoML is a Python library for building online serving systems optimized for AI apps and model inference. Rated critica

CVE-2014-0224 HIGH POC
7.4 Jun 05

OpenSSL before 0.9.8za, 1.0.0 before 1.0.0m, and 1.0.1 before 1.0.1h does not properly restrict processing of ChangeCiph

CVE-2024-21644 HIGH POC
7.5 Jan 08

pyLoad download manager version prior to 0.5.0b3.dev77 exposes the Flask SECRET_KEY through an unauthenticated endpoint.

CVE-2026-33017 CRITICAL POC
9.3 Mar 17

Langflow (a visual LLM pipeline builder) contains a critical unauthenticated code execution vulnerability (CVE-2026-3301

CVE-2017-9462 HIGH POC
8.8 Jun 06

In Mercurial before 4.1.3, "hg serve --stdio" allows remote authenticated users to launch the Python debugger, and conse

CVE-2026-49869 CRITICAL POC
10.0 Jun 26

Unauthenticated remote code execution affects Kestra OSS (the open-source event-driven orchestration platform) prior to

CVE-2026-39987 CRITICAL POC
9.3 Apr 08

Unauthenticated remote code execution in Marimo ≤0.20.4 allows attackers to execute arbitrary system commands via the `/

CVE-2024-21645 MEDIUM POC
5.3 Jan 08

pyLoad is the free and open-source Download Manager written in pure Python. Rated medium severity (CVSS 5.3), this vulne

Vendor StatusVendor

SUSE

Product Status
openSUSE Tumbleweed Fixed

This site uses cookies essential for authentication and security. No tracking or analytics cookies are used. Privacy Policy