Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessDeliver malicious SVG to victim's JupyterLab workspace
-
DeliveryVictim opens SVG in ImageViewer plugin
-
ExploitVictim opens image in new browser tab
-
ExecutionSVG JavaScript executes in JupyterLab same-origin context
-
PersistXSS payload calls JupyterLab kernel REST API
-
ImpactArbitrary OS commands execute on JupyterLab server
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A05:2025 - Injection
ASVS 5.0
V1 - Encoding and Sanitization Output encoding, context-aware escaping
MITRE ATT&CK
2 techniques across 2 tactics: Initial Access, Execution The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up. |
| Exploitation Conditions | Three conditions must simultaneously hold: (1) JupyterLab version must be <= 4.5.9 or 4.6.0-4.6.1; (2) the ImageViewer plugin (@jupyterlab/imageviewer-extension:plugin) must be enabled - it is enabled by default in all affected versions, so no non-default configuration is required on the server side; and (3) the victim must perform two active steps: first open the malicious SVG through the ImageViewer, then manually open it in a new browser tab. The critical exploitation limit is this mandatory two-step user interaction - simply viewing the SVG in the ImageViewer panel is insufficient to trigger the XSS. The attacker must first deliver the SVG file to a location accessible in the victim's JupyterLab session (shared filesystem in JupyterHub, uploaded artifact, or notebook-attached file). CVSS PR:N confirms no server-side authentication is required to trigger the vulnerability once the file is in the victim's accessible workspace; however, delivering the file to a targeted user's workspace may itself require some form of access in isolated deployments. |
| Impact | The CVSS 4.0 score of 7.5 (AV:N/AC:H/AT:N/PR:N/UI:A/VC:H/VI:H/VA:L) accurately captures the two-part tension of this vulnerability: the attack complexity is high because exploitation requires the victim to perform two distinct actions (open the SVG in ImageViewer, then explicitly open it in a new browser tab), yet the downstream impact is severe - VC:H and VI:H reflect full confidentiality and integrity compromise of the JupyterLab server. PR:N confirms no authentication is required to deliver and trigger the payload once a file is in scope. The UI:A (active interaction) flag is the principal limiting factor and distinguishes this from a one-click exploit. In multi-user JupyterHub deployments where datasets and notebooks are shared, social engineering a victim into this two-step sequence is realistic: inspecting an image in a new tab is a natural workflow. For isolated single-user local deployments, risk is lower since an attacker must first place a malicious SVG on the local filesystem. No EPSS score was provided in the input data; no KEV listing exists; no public PoC has been identified. The CVSS 4.0 SC:N/SI:N/SA:N metrics may understate risk in networked deployments where the JupyterLab server has access to downstream systems, but this is context-dependent and cannot be confirmed from available data. |
| Exploit ScenarioDerived | An attacker operating in a shared JupyterHub environment uploads a specially crafted SVG file to a shared dataset directory or sends it via a notebook attachment. A data scientist opens the file through JupyterLab's ImageViewer (the default handler for image files) and, wanting a closer look, right-clicks and opens it in a new browser tab - a routine workflow step. The SVG's embedded JavaScript executes in the JupyterLab server's same-origin context and silently posts a request to the kernel API to run an OS command, exfiltrating credentials or establishing a reverse shell on the server. No public exploit code has been identified at time of analysis. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Aug 12, 2026
JupyterLab's ImageViewer component escalates a blob URL lifecycle bug into server-side remote code execution - a specially crafted SVG opened in the ImageViewer retains an executable same-origin context after its blob URL is prematurely revoked, and when the victim opens that image in a new browser tab, embedded JavaScript executes within the JupyterLab server's origin. That same-origin privilege grants direct access to JupyterLab's kernel execution API, turning a browser-side XSS into full RCE on the JupyterLab server. All versions prior to 4.5.10 and 4.6.2 are affected; no public exploit has been identified at time of analysis and the vulnerability is not listed in CISA KEV, but the two-step user interaction required is realistic in data-science workflows where images are routinely inspected.
RemediationAI
Upgrade JupyterLab to v4.5.10 (for installations on the 4.5.x branch) or v4.6.2 (for the 4.6.x branch) - both are vendor-confirmed patched releases referenced at the GitHub releases page and backed by pull requests #19184, #19185, and #19186. If an immediate upgrade is not feasible, the vendor-documented workaround is to disable the ImageViewer plugin entirely: run jupyter labextension disable @jupyterlab/imageviewer-extension:plugin and confirm the change with jupyter labextension list. The trade-off of this workaround is that all in-application image preview functionality is lost for all image types, not only SVGs, which may impact data science workflows relying on inline image inspection. JupyterHub administrators managing multi-user deployments should treat this as a priority patch, since shared dataset storage creates a plausible delivery vector for a malicious SVG to reach multiple users. The vendor advisory is at https://github.com/jupyterlab/jupyterlab/security/advisories/GHSA-gx64-gj6p-pc4c.
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 is a web-based IDE that runs a Python server (locally or hosted) and serves a browser-based frontend sharing the server's origin. The vulnerable code is in packages/imageviewer/src/widget.ts, where the ImageViewer widget calls URL.createObjectURL to generate a temporary blob URL for an SVG file, then immediately revokes it via URL.revokeObjectURL. The premature revocation does not fully neutralize the blob's content - the browser retains the rendered SVG in a navigable same-origin context. Because SVGs can embed JavaScript (e.g., via script elements or event handlers), and the blob URL shares the JupyterLab server's origin, opening the rendered image in a new tab allows that JavaScript to execute with full same-origin trust. CWE-79 (Improper Neutralization of Input During Web Page Generation) applies because SVG script content is not sanitized before being surfaced in an executable browser context. The same-origin position then grants the attacker access to JupyterLab's REST API for kernel management, enabling arbitrary OS command execution on the backing server. The affected pip package is jupyterlab, vulnerable at versions <= 4.5.9 and 4.6.0-4.6.1.
Know when the next one hits your stack
- 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
CVSS:4.0/AV:N/AC:H/AT:N/PR:N/UI:A/VC:H/VI:H/VA:L/SC:N/SI:N/SA:N
Network-delivered SVG requires active two-step user interaction (AC:H, UI:R); XSS crosses to server kernel API, constituting a scope change (S:C); full confidentiality and integrity compromise on server, low availability impact.
Primary rating from Vendor (github).
CVSS VectorVendor: github
Lifecycle Timeline
2DescriptionCVE.org
jupyterlab is an extensible environment for interactive and reproducible computing, based on the Jupyter Notebook Architecture. Prior to 4.5.10 and 4.6.2, in packages/imageviewer/src/widget.ts, JupyterLab's ImageViewer uses URL.createObjectURL for a specially crafted SVG image and revokes the blob URL too early, allowing the image to retain an executable same-origin context when it is opened through the image viewer and then opened in a new browser tab. The resulting cross-site scripting can be used to execute arbitrary code on the JupyterLab server. This issue is fixed in versions 4.5.10 and 4.6.2.
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 ImageViewer contains a remote code execution vulnerability affecting versions prior to 4.5.10 and 4.6.2 that could allow attackers to execute arbitrary code on data science and research servers through specially crafted image files. Organizations using JupyterLab face potential compromise of sensitive research data, intellectual property, and computational infrastructure if users interact with attacker-supplied SVG files.
Disable or restrict SVG file handling in ImageViewer; implement file upload restrictions limiting uploads to trusted internal sources only; segment JupyterLab instances on isolated networks with egress filtering; monitor kernel execution API activity for anomalous patterns; enforce access controls limiting user interaction with JupyterLab to necessary personnel only.
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
Priority Score
Attack Technique
Cross-Site Scripting occurs when an application accepts untrusted data and sends it to a web browser without proper validation or encoding.
Remote Code Execution represents the critical moment when an attacker successfully runs arbitrary code on a target system without physical access.
EUVD-2026-57535
GHSA-gx64-gj6p-pc4c
NVD
CVE.org
EPSS
Vulnrichment
VulDB
Exploit-DB