Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessIdentify target using Mamba
-
DeliveryPublish weaponized model to HuggingFace
-
ExploitSocial engineer victim to load malicious model
-
ExecutionVictim calls from_pretrained()
-
PersistPickle deserialization executes payload
-
ImpactEstablish persistence and lateral movement
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A08:2025 - Software or Data Integrity Failures
ASVS 5.0
V1 - Encoding and Sanitization Safe deserialization, type allowlists
MITRE ATT&CK
2 techniques across 2 tactics: Execution, Initial Access The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up. |
| Exploitation Conditions | Exploitation requires the victim to explicitly call MambaLMHeadModel.from_pretrained() or equivalent model loading functions targeting an attacker-controlled or compromised HuggingFace Hub repository. The victim must have network connectivity to HuggingFace Hub or another model hosting service containing the malicious model. No special Mamba framework configuration or non-default features are required-the vulnerability exists in default model loading behavior. Limiting factors include: victim must make the conscious decision to download and load a specific external model (social engineering or supply chain compromise required); many organizations use private model registries or airgapped environments that prevent loading arbitrary HuggingFace models; security-conscious teams already implement model verification workflows that would detect anomalous pickle content; the attack leaves forensic artifacts in download history and model cache directories. The CVSS UI:N rating is misleading-while no interactive prompt blocks exploitation, the attack fundamentally depends on user action (model selection and loading), not automated scanning or wormable propagation. |
| Impact | CVSS 9.8 (AV:N/AC:L/PR:N/UI:N) indicates maximum exploitability: network-accessible, low complexity, no authentication or user interaction required. However, this critically overstates real-world risk for this specific vulnerability. Exploitation requires the victim to explicitly load a model from an attacker-controlled or compromised HuggingFace repository-the attack is not against the Mamba library itself but against users who trust malicious model sources. The CVSS UI:N rating is arguably incorrect since a user must intentionally call from_pretrained() with a specific repository identifier. EPSS 0.02% (5th percentile) aligns with actual low exploitation likelihood, reflecting that attacks require social engineering to convince targets to load malicious models and that the ML community increasingly scrutinizes model provenance. Not present in CISA KEV, indicating no confirmed widespread exploitation. Real risk is moderate for organizations with poor supply chain hygiene around ML models, but low for environments with model verification processes. The vulnerability's impact is legitimately critical (full system compromise), but attack complexity is realistically medium-to-high despite CVSS rating, as it depends on trust exploitation rather than technical vulnerability exploitation alone. |
| Exploit ScenarioDerived | An attacker creates a malicious Mamba model on HuggingFace Hub by crafting a pytorch_model.bin file containing a pickled Python object with a __reduce__ method that executes reverse shell code. The attacker publishes this model under a convincing name like 'mamba-sota-2026' and promotes it through ML forums or academic preprints. A researcher or developer, trusting the HuggingFace platform, runs victim_model = MambaLMHeadModel.from_pretrained('attacker/mamba-sota-2026') in their Jupyter notebook or production pipeline. During model loading, torch.load() deserializes the malicious pickle, triggering arbitrary code execution that establishes persistence, exfiltrates credentials from the development environment, and pivots to connected systems with the developer's privileges. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – May 14, 2026
Remote code execution in Mamba language model framework (through version 2.2.6) allows unauthenticated attackers to execute arbitrary Python code by publishing malicious models on HuggingFace Hub. When victims call MambaLMHeadModel.from_pretrained() on a weaponized model repository, insecure pickle deserialization executes attacker-controlled code in the context of the victim's process. Despite the critical CVSS 9.8 score and network attack vector requiring no authentication, EPSS probability remains extremely low (0.02%, 5th percentile), suggesting limited real-world exploitation to date. No CISA KEV listing or public POC identified at time of analysis.
RemediationAI
Primary remediation requires upgrading the Mamba framework to a patched version that implements weights_only=True in torch.load() calls within from_pretrained() methods-however, no vendor-released patch version is confirmed from available data at time of analysis; monitor the official GitHub repository (github.com/state-spaces/mamba) and PyPI for security updates. Immediate compensating control: implement model provenance verification by only loading models from explicitly whitelisted, organization-controlled repositories; cryptographically verify model file hashes against known-good values before loading; this prevents execution but adds operational overhead for model updates. Advanced mitigation: monkey-patch torch.load in application initialization to force weights_only=True globally (may break legitimate non-tensor pickle data); this could cause compatibility issues with models using custom serialization. Containerization mitigation: run Mamba model loading in isolated containers with minimal privileges and no network access post-download; limits blast radius but does not prevent initial compromise. Long-term: migrate to safer serialization formats like safetensors which stores only tensor data without pickle vulnerabilities; requires model re-export and framework support. For security-critical environments, consider disabling HuggingFace Hub integration entirely and distributing models through internal registries with mandatory security scanning.
Affected VersionsENISA
Affected Packages
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
Mamba is a state-space model framework for sequence modeling and language models, competing with transformer architectures. The vulnerability stems from torch.load() deserializing PyTorch model weights using Python's pickle protocol without the weights_only=True security parameter introduced in PyTorch 1.13+ to restrict deserialization to tensor data only. CWE-502 (insecure deserialization) occurs when untrusted data is deserialized without validation-in this case, the pytorch_model.bin file from third-party HuggingFace repositories. The pickle format can serialize arbitrary Python objects including executable code via __reduce__ magic methods, enabling attackers to embed malicious code in model weight files that executes during the unpickling process when from_pretrained() loads the model.
Know when Python gets its next vulnerability
- 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
AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H
Primary rating from Vendor (mitre) · only source for this CVE.
CVSS VectorVendor: mitre
Lifecycle Timeline
3DescriptionCVE.org
The mamba language model framework thru 2.2.6 is vulnerable to insecure deserialization (CWE-502) when loading pre-trained models from HuggingFace Hub. The MambaLMHeadModel.from_pretrained() method uses torch.load() to load the pytorch_model.bin weight file without enabling the security-restrictive weights_only=True parameter. This allows the deserialization of arbitrary Python objects via the pickle module. An attacker can exploit this by publishing a malicious model repository on HuggingFace Hub. When a victim loads a model from this repository, arbitrary code is executed on the victim's system in the context of the mamba process.
Executive ViewAI
Mamba language model framework versions through 2.2.6 contain a critical remote code execution vulnerability allowing unauthenticated attackers to inject malicious code through compromised model repositories on HuggingFace Hub. Organizations using Mamba for machine learning inference face immediate risk of arbitrary code execution in production environments if they load untrusted model files, potentially compromising data, systems, and downstream applications.
No vendor-released patch identified at time of analysis. Interim mitigations: (1) Restrict Mamba model loading to internally-vetted, digitally-signed models only; (2) Run Mamba inference in isolated containers with minimal privileges and filesystem access; (3) Implement strict network egress controls to block unauthorized outbound connections from Mamba processes; (4) Use sandboxed execution environments for any user-supplied or external model repositories; (5) Monitor HuggingFace Hub for suspicious model activity related to your organization's commonly-used models; (6) Consider forking trusted model repositories locally and disabling automatic remote updates until patch availability.
Threat Intelligence Overview
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.
What every action level means
SSVC AssessmentENISA
Priority Score
Attack Technique
Insecure deserialization occurs when an application converts serialized data (a stream of bytes representing an object's state) back into a living object without proper validation.
Remote Code Execution represents the critical moment when an attacker successfully runs arbitrary code on a target system without physical access.
Wazuh SIEM platform versions 4.4.0 through 4.9.0 contain an unsafe deserialization vulnerability in the DistributedAPI t
BentoML version 1.4.2 and earlier contains an unauthenticated remote code execution vulnerability through insecure deser
pgAdmin 4 contains critical remote code execution vulnerabilities in the Query Tool download and Cloud Deployment endpoi
The renderLocalView function in render/views.py in graphite-web in Graphite 0.9.5 through 0.9.10 uses the pickle Python
BentoML is a Python library for building online serving systems optimized for AI apps and model inference. Rated critica
OpenSSL before 0.9.8za, 1.0.0 before 1.0.0m, and 1.0.1 before 1.0.1h does not properly restrict processing of ChangeCiph
pyLoad download manager version prior to 0.5.0b3.dev77 exposes the Flask SECRET_KEY through an unauthenticated endpoint.
Langflow (a visual LLM pipeline builder) contains a critical unauthenticated code execution vulnerability (CVE-2026-3301
In Mercurial before 4.1.3, "hg serve --stdio" allows remote authenticated users to launch the Python debugger, and conse
Unauthenticated remote code execution affects Kestra OSS (the open-source event-driven orchestration platform) prior to
Unauthenticated remote code execution in Marimo ≤0.20.4 allows attackers to execute arbitrary system commands via the `/
pyLoad is the free and open-source Download Manager written in pure Python. Rated medium severity (CVSS 5.3), this vulne
EUVD-2026-29562
GHSA-pq2f-x424-6fjm
NVD
CVE.org
EPSS
Vulnrichment
Exploit-DB