Skip to main content

Flair NLP CVE-2026-76843

| EUVDEUVD-2026-64849 HIGH
Deserialization of Untrusted Data (CWE-502)
2026-08-24 VulnCheck GHSA-58g9-h5rx-pf95
8.4
CVSS 4.0 · Vendor: VulnCheck
View

Attack ChainAIDerived

Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain

  1. Access
    Attacker crafts malicious pickle-embedded joblib file
  2. Delivery
    Delivers poisoned model file to victim filesystem via download or shared storage
  3. Exploit
    Victim pipeline calls ClusteringModel.load() on the file
  4. Execution
    joblib.load() reads file, pickle.loads() deserializes payload
  5. Impact
    Arbitrary 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.

This Week Schedule remediation this week. Why: HIGH severity (CVSS 7.0-8.9).
No patch listed yet 0.1% exploitation probability (EPSS)

Get an e-mail when this CVE is exploited, patched or re-scored. Free account.

Alert me

AnalysisAIv1 – 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

flair 0.15.0 ≤0.15.1

Affected Packages

euvd flair no fix

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

Vendor (VulnCheck) PRIMARY 8.4 HIGH
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
vuln.today AI 7.8 HIGH

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.

3.1 AV:L/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H
4.0 AV:L/AC:L/AT:N/PR:N/UI:A/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N

Primary rating from Vendor (VulnCheck).

CVSS VectorVendor: VulnCheck

Attack Vector
Local
Attack Complexity
Low
Attack Requirements
None
Privileges Required
None
User Interaction
Active
Vulnerable system: Confidentiality
High
Vulnerable system: Integrity
High
Vulnerable system: Availability
High
Subsequent system: Confidentiality
None
Subsequent system: Integrity
None
Subsequent system: Availability
None

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.

Executive ViewAI

Why It Matters

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.

Business Impact: High
Compensating Controls

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

EPSS Score
0.1%
Top 96% exploitable
Prevalence
Medium
popular NLP research library, limited broad production infrastructure deployment
Data Quality
7 sources
Confidence: High
EUVD NVD CVE.org EPSS Vulnrichment GitHub VulDB

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.

SignalValue
Severity HIGH
CISA KEV No
Public POC No
EPSS 0.1%
Patch available No
Active threat No
Deciding rule
HIGH severity (CVSS 7.0-8.9)
What every action level means
Emergency Immediate action required. Criteria: CRITICAL + in CISA KEV (actively exploited) without patch, OR CRITICAL + EPSS > 30% without patch, OR CRITICAL + active threat signals without patch.
Act Now Prioritize within 24-48h. Criteria: in KEV with patch available, OR CRITICAL + public POC, OR HIGH + EPSS > 10%, OR CRITICAL + active threat, OR any CRITICAL severity.
This Week Schedule remediation this week. Criteria: HIGH severity (CVSS 7.0-8.9). Patch within normal change window.
This Month Plan within 30 days. Criteria: MEDIUM severity (CVSS 4.0-6.9), lower exploitation probability. Include in regular patch cycle.
Monitor Track and reassess. Criteria: LOW severity (CVSS 0.1-3.9), minimal exploitation risk. No immediate action needed.

SSVC AssessmentENISA

SSVC Decision
Scheduled
Exploitation
None
System Exposure· derived
Small
Automatable
No
Human Impact
High
Technical Impact
Total

Priority Score

42
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +42
PoC: 0
Weaponized: 0
Threat intel: 0
Gov advisory: 0

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.

This site uses cookies essential for authentication and security. No tracking or analytics cookies are used. Privacy Policy