Authlib's OAuth 2.0 authorization endpoint in kimi-cli versions prior to 1.6.10, certain 1.7.x versions, and some 2.x versions contains an open redirect vulnerability. This occurs when an unsupported response_type is used along with an attacker-controlled redirect_uri, allowing redirection without client validation or user authentication. The flaw exists because the server returns a redirect response to the supplied redirect_uri before validating the client or redirect URI. This vulnerability has a CVSS score of 5.4 (medium severity) and affects multiple versions as specified. A patch is available to address this issue.
JupyterLab versions 3.3.0 up to but not including 4.6.2 contain a cross-site scripting (XSS) vulnerability via crafted settings files named overrides.json. This file can be imported by users or automatically loaded from configuration directories. The vulnerability allows embedded code in the settings file to execute with the user's privileges, potentially reading or modifying notebooks and running code on the notebook server and connected kernels. The issue arises because certain notebook display settings were not properly validated before application. Patches are available in versions 4.6.2 and later.
JupyterLab versions from 4.5.0 up to but not including 4.6.2 have a vulnerability in the PyPI extension manager's blocklist enforcement. Authenticated users can bypass package-name blocking by using PyPI-equivalent spellings, allowing installation of otherwise blocked extensions. This can impact the integrity and availability of the single-user server instance, especially in deployments with custom allow/block lists and restricted kernel access. The issue is fixed in version 4.6.2.
JupyterLab's image viewer contains a cross-site scripting (XSS) vulnerability when opening a specially crafted image file and then opening it in a new browser tab. This vulnerability can lead to remote code execution on the JupyterLab server. Versions prior to 4.6.2 are affected. The issue is patched in versions 4.6.2 and 4.5.10. As a workaround, disabling the image viewer plugin can mitigate the risk.
JupyterLab versions from 1.2.0 up to but not including 4.5.7_1 contain a vulnerability where the HTML sanitizer allowlists certain attributes that enable one-click execution of arbitrary JupyterLab commands from untrusted HTML content. This can lead to arbitrary code execution, file deletion, and denial of service by exhausting server resources. The vulnerability can be exploited by an attacker sharing a malicious notebook or Markdown file that contains deceptive buttons triggering commands upon user clicks. The issue is patched in version 4.5.7_1. No end-user workarounds exist, but downstream applications can disable the CommandLinker functionality. The patched versions also allow disabling the command linker via configuration.
JupyterLab versions prior to 4.5.7 have a vulnerability where the allow-list for extensions installable via the PyPI Extension Manager is not properly enforced. This allows authenticated users in multi-tenant or restricted environments to install arbitrary third-party extensions, potentially escalating privileges and compromising server security. The issue is patched in version 4.5.7. Workarounds include switching the extension manager to read-only mode.
JupyterLab versions prior to 4.0.11 are vulnerable to a flaw that can expose users' Authorization and XSRF tokens if they click on a malicious link while running an older jupyter-server version. This vulnerability allows potential leakage of sensitive authentication tokens. The issue has been patched in JupyterLab 4.0.11 and later versions. Users are advised to upgrade jupyter-server to version 2.7.2 or newer to mitigate the risk, as no other workarounds are available.
Tornado's CurlAsyncHTTPClient class in versions >=1.2.0 and <4.2.3 allows CRLF injection in HTTP request headers. This occurs because Tornado does not validate or reject carriage return and line feed characters in header values, enabling attackers to inject arbitrary headers or even additional HTTP requests. This vulnerability differs from the standard AsyncHTTPClient, which properly rejects such characters. The issue stems from libcurl and pycurl passing header strings verbatim without filtering control characters. Exploitation may facilitate server-side request forgery (SSRF) attacks. A fix is available in Tornado version 4.2.3.
CVE-2024-14029 is a vulnerability in Tornado used by JupyterLab where the server inconsistently handles HTTP requests containing multiple Transfer-Encoding: chunked headers. This flaw enables HTTP request smuggling when Tornado is deployed behind proxies that forward such malformed requests. The issue is fixed in Tornado version 4.2.3.
A vulnerability in JupyterLab's use of Tornado's AsyncHTTPClient allows a malicious server to cause excessive memory consumption via decompressed gzip chunks without a size limit. This can lead to denial of service due to resource exhaustion. The issue affects versions from 1.2.0 up to but not including 4.5.8 and is fixed in version 4.5.8.
A high-severity vulnerability in Tornado's httputil.py _parseparam function causes quadratic CPU usage when parsing crafted multipart/form-data parameters. This can lead to a denial of service by making the server unresponsive due to its single event loop design. Versions of jupyterlab from 1.2.0 up to but not including 4.5.1 are affected. The issue is fixed in version 4.5.1.
CVE-2025-67725 is a high-severity vulnerability in Tornado's HTTPHeaders.add method where repeated header names cause quadratic time complexity due to string concatenation. This can block the server's single event loop, leading to a Denial of Service (DoS). The impact is higher if the max_header_size setting is increased beyond the default 64KB. The issue affects jupyterlab versions from 1.2.0 up to but not including 4.5.1. A fix is available in version 4.5.1.
CVE-2024-49766 is a vulnerability in icloudpd versions 1.21.0 through 1.23.x on Windows systems running Python versions earlier than 3.11. The issue arises because Werkzeug's safe_join() function relies on os.path.isabs() to detect absolute paths, but on these Python versions on Windows, os.path.isabs() does not correctly identify UNC paths (e.g., //server/share) as absolute. This can lead to unsafe path joins, potentially allowing unintended access to data. The vulnerability is fixed in icloudpd version 1.24.0.
PyJWT versions from 2.4.0 up to but not including 2.12.1 contain a vulnerability in the handling of detached JWS tokens with the unencoded-payload option (b64=false). The library performs Base64URL decoding of the payload segment before enforcing detached payload rules, causing unnecessary CPU and memory usage even if the signature is invalid. This allows an unauthenticated remote attacker to cause a denial of service (DoS) by sending tokens with large payload segments, amplifying resource consumption on the server.
PyJWKClient in PyJWT versions before 2026.7.1 does not restrict URL schemes when fetching JSON Web Key Sets (JWKS), allowing attacker-controlled URLs with schemes like file://, ftp://, or data:. This can lead to server-side request forgery (SSRF) to local files or other resources. Additionally, if an attacker can write to a location referenced by a file:// URL, they can forge JWT tokens that the application will accept as valid. The vulnerability is fixed in version 2026.7.1 by adding an allowed schemes whitelist.
CVE-2024-6345 is a high-severity vulnerability in the package_index module of pypa/setuptools up to version 69.1.1 that allows remote code execution via command injection through package URLs. The flaw occurs in download functions that process user-controlled or package index server URLs, enabling arbitrary command execution if exposed to untrusted inputs. This issue is fixed in setuptools version 70.0.
Starlette, a Python web framework used by applications such as Glances and FastAPI, has a denial of service (DoS) vulnerability (CVE-2024-47874) related to handling multipart/form-data requests. Specifically, parts without a filename are treated as text form fields and buffered without size limits, allowing attackers to upload arbitrarily large form fields. This can cause excessive memory consumption, server slowdowns, and potential process termination due to out-of-memory (OOM) conditions. The vulnerability affects all Starlette-based applications accepting form requests prior to version 4.5.6.
GitPython versions up to 3.1.50 contain a vulnerability where the Repo.clone_from() method expands environment variables in the clone URL using os.path.expandvars(). This allows an attacker controlling the URL argument to embed environment variable tokens that get expanded to secret values from the server's environment and sent to an attacker-controlled host. The flaw arises because the URL is expanded without scheme validation before being passed to git clone, leading to secret exfiltration. A fix is available in version 2.4.5_1.
A vulnerability in the parse_form() function allows a negative Content-Length header to cause the entire request body to be buffered in memory at once instead of being read in chunks. This can degrade availability under concurrent requests but does not cause a complete denial of service. No known popular packages are affected, and the issue mainly impacts bespoke WSGI or http.server handlers that forward raw client headers without normalization. The issue is fixed in version 3.4.1.