/

CVE-2026-73626

Severity:

HIGH RISK

(7.5)

Authorization Bypass (CWE-284) in JupyterLab Install

CVE-2026-73626

Awaiting Analysis

Vulnerability type

Category:

Authorization Bypass

CWE:

CWE-284

Impact:

Unauthorized Extension Installation

Severity:

HIGH RISK

(7.5)

CVSS version:

3.1

Catch this CVE while code is being written

Detect vulnerable code directly in pull requests, so CVEs are fixed before merge.

Summary

JupyterLab contains an authorization enforcement gap in PyPIExtensionManager.install() because a required asynchronous policy check was not awaited. In narrowly configured deployments, a custom integration may allow an unauthorized extension to be installed when its package name is influenced by untrusted input and an extension allowlist or blocklist is enabled.

Affected context

The issue affects deployments using the PyPI Extension Manager where a custom extension or downstream integration imports PyPIExtensionManager and calls install() directly. The risk is conditional on untrusted input influencing the package name, an allowlist or blocklist being configured, and kernels and terminals being disabled or delegated to remote hosts. The standard JupyterLab HTTP API and Extension Manager UI perform a separate correctly awaited authorization check and are not affected by this specific gap.

Exploit preconditions

  • Attack surface: A custom extension or downstream integration that directly invokes PyPIExtensionManager.install()
  • Required access: Ability to influence the package name supplied to that direct caller; direct access to the stock UI or HTTP API alone is insufficient
  • Configuration: The PyPI Extension Manager must be enabled and an extension allowlist or blocklist must be configured
  • Trigger point: Direct installation through PyPIExtensionManager.install()
  • Additional deployment condition: Kernels and terminals must be disabled or delegated to remote hosts
  • Why exploitation is possible: The asynchronous authorization check is invoked without awaiting its result, allowing the installation path to proceed without enforcing the configured policy

Why this happens

The underlying bug is an asynchronous authorization check whose coroutine is created but not awaited. As a result, the policy decision is not actually executed before the installation operation continues. This maps to CWE-284, Improper Access Control, because a configured authorization policy is present but not reliably enforced on a direct installation path. The issue is specific to the direct caller path and does not describe the separately checked stock HTTP API or UI flows.

Potential impact

  • An attacker may install an extension that violates the configured allowlist or blocklist
  • A malicious or untrusted extension could execute code within the JupyterLab server's permitted context
  • The affected environment could experience data exposure, tampering, or service disruption
  • Additional systems or resources may be reachable if the JupyterLab process has excessive privileges

General mitigation guidance

Mitigation generally focuses on making authorization checks mandatory and

enforcing them consistently at every installation entry point.

Common defensive patterns include:

  • Await asynchronous authorization results before performing installation actions
  • Centralize extension policy enforcement in a shared installation boundary
  • Avoid exposing direct package-installation methods to untrusted input
  • Validate package identifiers and apply explicit allowlists where feasible
  • Run JupyterLab with least-privilege permissions and isolate extension execution
  • Keep kernels and terminals separated from sensitive infrastructure when they are not required
  • Treat downstream integrations and custom extensions as part of the security boundary

How teams detect issues like this

Organizations can look for this class of issue through:

  • Static analysis rules that identify coroutine-returning authorization methods used without await
  • Code review checks for direct calls to extension installation APIs
  • Tests that attempt policy-disallowed installations through every available entry point
  • Runtime audit logging for extension installation requests, package names, and authorization outcomes
  • Policy enforcement that requires all package installation paths to pass through a centralized authorization layer
  • Automated code review tools that flag unawaited security-sensitive asynchronous operations

Sources

SourceLink
github.comgithub.com/jupyterlab/jupyterlab/security/advisories/GHSA-whvh-wf3x-g77j
vulncheck.comvulncheck.com/advisories/jupyterlab-before-authentication-bypass-via-pypiextensionmanager

Frequently asked

questions

No. The described issue affects direct callers of PyPIExtensionManager.install().

The stock HTTP API and Extension Manager UI perform a separate, correctly

awaited policy check.

An attacker must be able to influence the package name passed by a custom

extension or downstream integration that directly invokes the installation

method. The PyPI Extension Manager must also be enabled and an allowlist or

blocklist configured.

Ensure the asynchronous authorization check is awaited and that every

installation path enforces the same policy before downloading or installing

an extension.

Test authorization on all public and internal entry points, use centralized

policy enforcement, monitor installation activity, and apply least privilege

to the JupyterLab process and its extensions.

Find out what's already
exploitable in your codebase.