Skip to main content

JupyterLab EUVDEUVD-2026-57535

| CVE-2026-73415 HIGH
Cross-site Scripting (XSS) (CWE-79)
2026-08-12 security-advisories@github.com GHSA-gx64-gj6p-pc4c
7.5
CVSS 4.0 · Vendor: github
View

Attack ChainAIDerived

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

  1. Access
    Deliver malicious SVG to victim's JupyterLab workspace
  2. Delivery
    Victim opens SVG in ImageViewer plugin
  3. Exploit
    Victim opens image in new browser tab
  4. Execution
    SVG JavaScript executes in JupyterLab same-origin context
  5. Persist
    XSS payload calls JupyterLab kernel REST API
  6. Impact
    Arbitrary 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.

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

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

Alert me

AnalysisAIv1 – 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

jupyterlab 4.6.0, < 4.6.2
jupyterlab < 4.5.10

Affected Packages

pypi jupyterlab fix: 4.5.10, 4.6.2

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

Vendor (github) PRIMARY 7.5 HIGH
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
vuln.today AI 8.2 HIGH

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.

3.1 AV:N/AC:H/PR:N/UI:R/S:C/C:H/I:H/A:L
4.0 AV:N/AC:H/AT:N/PR:N/UI:A/VC:H/VI:H/VA:L/SC:N/SI:N/SA:N
SUSE MEDIUM
Red Hat 8.0 HIGH

Primary rating from Vendor (github).

CVSS VectorVendor: github

Attack Vector
Network
Attack Complexity
High
Attack Requirements
None
Privileges Required
None
User Interaction
Active
Vulnerable system: Confidentiality
High
Vulnerable system: Integrity
High
Vulnerable system: Availability
Low
Subsequent system: Confidentiality
None
Subsequent system: Integrity
None
Subsequent system: Availability
None

Lifecycle Timeline

2
Patch available
Aug 12, 2026 - 21:17 EUVD
CVE Published
Aug 12, 2026 - 20:17 cve.org
HIGH 7.5

DescriptionCVE.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
† from your stack dependencies † transitive graph · vuln.today resolves 4-path depth
  • 5 pypi packages depend on jupyterlab (2 direct, 3 indirect)

Ecosystem-wide dependent count for version 4.6.0.

Executive ViewAI

Why It Matters

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.

Business Impact: High
Compensating Controls

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

EPSS Score
0.6%
Top 56% exploitable
Prevalence
High
dominant interactive computing IDE in data science and research globally
Threat Intel
1
1 source
Data Quality
7 sources
Confidence: High
EUVD NVD CVE.org EPSS Vulnrichment 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.6%
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
Scheduled
Exploitation
None
System Exposure· derived
Open
Automatable
No
Human Impact
High
Technical Impact
Total

Priority Score

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

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.

Vendor StatusVendor

SUSE

Severity: Moderate

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