Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessAttacker crafts malicious pickle-embedded joblib file
-
DeliveryDelivers poisoned model file to victim filesystem via download or shared storage
-
ExploitVictim pipeline calls ClusteringModel.load() on the file
-
Executionjoblib.load() reads file, pickle.loads() deserializes payload
-
ImpactArbitrary Python executes with loading process OS privileges
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 process to explicitly import flair.models.clustering and call ClusteringModel.load() on a file the attacker controls - a module removed from Flair's documented API but still present and importable in the 0.15.0 and 0.15.1 PyPI wheels. The malicious model file must be accessible on the local filesystem at the time of the load call (AV:L per the CVSS 4.0 vector), which in practice means the attacker must deliver it via download, shared storage, or file transfer to the victim host before or during execution. Active interaction is required (UI:A): an automated pipeline or human operator must initiate the ClusteringModel.load() call. Exploitation is limited by: (1) the module being absent from Flair's documented API, reducing the likelihood of new code using it; (2) the mandatory local file access step, which requires a prior delivery mechanism; and (3) the absence of any network-listening component in Flair itself that could be directly targeted. Organizations that have fully audited their codebases and confirmed no calls to ClusteringModel.load() or imports of flair.models.clustering are not at direct risk from this specific path. |
| Impact | The CVSS 4.0 score of 8.4 reflects full system compromise potential (VC:H/VI:H/VA:H) constrained by local attack vector (AV:L) and required active user interaction (UI:A). Real-world risk is highly context-dependent: in automated ML pipelines that ingest model files from external repositories, model hubs, or shared network storage, the local-file constraint is easily satisfied during normal workflow execution, elevating practical risk significantly above what AV:L implies in a traditional software context. Exploitation is not passive or network-facing - a victim process must explicitly call ClusteringModel.load() on a reachable malicious file. The most dangerous scenario is legacy or research code that previously used ClusteringModel and was not audited after the CVE-2024-10073 'fix,' leaving teams with a false belief in remediation. EPSS data is absent from available intelligence. KEV status is not confirmed. No public exploit code has been identified, keeping realized exploitation probability currently low, but the technique (pickle deserialization) requires no novel research and is thoroughly documented. |
| Exploit ScenarioDerived | An attacker crafts a malicious joblib-wrapped pickle payload that spawns a reverse shell or exfiltrates environment variables and credentials upon deserialization. They upload this file to a public model repository, shared NFS mount, or S3 bucket used by a target organization's ML training pipeline. When an automated training job or data scientist calls ClusteringModel.load() on the poisoned file - operating under the assumption that clustering support was safely removed in 0.15.0 - the payload executes with the OS privileges of the Python process, achieving full host compromise. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Aug 24, 2026
Unsafe pickle deserialization in Flair 0.15.0 and 0.15.1 allows arbitrary code execution with the privileges of the loading process when a victim calls ClusteringModel.load() on an attacker-supplied model file. The critical compounding factor is a false remediation: CVE-2024-10073 designated 0.15.0 as the fixed version after clustering was dropped from the documented API, but flair/models/clustering.py remains physically present in the PyPI-distributed wheels for both 0.15.0 and 0.15.1 and is directly importable, voiding the prior CVE's resolution. No public exploit has been identified at time of analysis, and the vulnerability is not listed in the CISA KEV catalog.
RemediationAI
No vendor-released patched version has been confirmed at time of analysis. Developers should treat all Flair 0.15.x installations as unpatched and apply the following specific controls: first, audit codebases for any direct or indirect calls to ClusteringModel.load() or imports of flair.models.clustering and remove or replace them immediately. Second, add an import-time guard by patching flair/models/clustering.py in the local site-packages to raise an ImportError unconditionally - this prevents accidental re-introduction with no functional impact since the class is undocumented. Third, enforce model file integrity verification (SHA-256 hashes or cryptographic signatures) for any externally sourced model files before they are passed to any Flair load method, as this mitigates the supply-chain poisoning vector regardless of the specific code path. Monitor the FlairNLP repository at https://github.com/flairNLP/flair and the PyPI package for a release that removes clustering.py from the distributed artifact, which would constitute a genuine fix.
Affected VersionsENISA
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 1 package in euvd
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
The vulnerable sink is ClusteringModel.load(), a static method in flair/models/clustering.py that chains joblib.load() followed by pickle.loads() on the result - both well-known unsafe deserialization mechanisms in Python. CWE-502 (Deserialization of Untrusted Data) precisely describes the root cause: Python's pickle module can execute arbitrary bytecode during object reconstruction, making any pickle.loads() call on attacker-controlled data an unconditional code execution primitive requiring no additional exploitation technique. The affected CPE is cpe:2.3:a:flairnlp:flair:*:*:*:*:*:*:*:* for versions 0.15.0 and 0.15.1. The architectural failure is a packaging artifact: the clustering module was excised from Flair's public API and documentation in 0.15.0, but the source file was not removed from the built wheel or sdist, leaving it importable via the direct path import flair.models.clustering. Security teams who closed CVE-2024-10073 tickets upon upgrading to 0.15.x are therefore exposed without any remediation signal.
Know when Flair 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
CVSS:4.0/AV:L/AC:L/AT:N/PR:N/UI:A/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N
Malicious file must be locally accessible (AV:L); calling ClusteringModel.load() requires active user or process action (UI:R); no credentials needed to load a file (PR:N); full pickle execution yields C/I/A:H.
Primary rating from Vendor (VulnCheck).
CVSS VectorVendor: VulnCheck
DescriptionCVE.org
The official Flair wheels for 0.15.0 and 0.15.1 still contain flair/models/clustering.py, whose ClusteringModel.load static method returns pickle.loads(joblib.load(str(model_file))) and so executes arbitrary Python while loading a model file. Loading a model supplied by an attacker therefore runs that attacker's code with the privileges of the loading process. This is the same sink and the same file as CVE-2024-10073, which records 0.15.0 as the fixed version on the basis that clustering support was dropped in that release; the module was removed from the documented API but remains present in the distributed artifact and reachable by importing flair.models.clustering directly, so the earlier record's fixed version does not hold for the shipped package.
Articles & Coverage 1
Executive ViewAI
Flair 0.15.0 and 0.15.1 contain an arbitrary code execution vulnerability triggered when loading attacker-supplied model files, affecting organizations that use these versions for machine learning workloads. The vulnerability stems from unsafe pickle deserialization in a module that was supposed to be removed in a prior CVE fix, creating a false sense of security that persists in current releases. Organizations must immediately assess their exposure and implement access controls around model file sources.
Restrict model file sources to trusted, internally-validated files only; implement network and file-based access controls preventing untrusted model files from reaching vulnerable systems; run Flair in sandboxed or containerized environments with minimal privilege to limit code execution scope; enable file integrity monitoring on model directories; disable or unload the clustering module if not required for operations.
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.
EUVD-2026-64849
GHSA-58g9-h5rx-pf95
NVD
CVE.org
EPSS
Vulnrichment
VulDB
Exploit-DB