Skip to main content

labbench EUVDEUVD-2026-115652

| CVE-2026-120833 HIGH
Deserialization of Untrusted Data (CWE-502)
2026-11-03 VulnCheck GHSA-4ppf-9g5f-q8hv
8.5
CVSS 4.0 · Vendor: VulnCheck
View

Attack ChainAIDerived

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

  1. Access
    Craft malicious pickle data file
  2. Delivery
    Deliver as dataset or relational archive
  3. Exploit
    Victim calls read()/read_relational()
  4. Execution
    Extension-based dispatch to pandas.read_pickle
  5. Persist
    Unpickling executes embedded payload
  6. Impact
    Arbitrary code runs as victim

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 a victim to invoke labbench's read() or read_relational() on an attacker-supplied file whose name ends in .p or .pickle (or a relational data archive containing such a file); vulnerable versions dispatch to pandas.read_pickle based on the extension alone, so no authentication or special privilege is needed but user interaction (loading the file) is mandatory - consistent with AV:L/UI:P. Limiting factors: the attack is not remote/network-triggered, it depends on social engineering to deliver and have the file opened, it only affects labbench versions before 0.46.1, and in 0.46.1 loading pickle files is refused by default unless the LABBENCH_AUTOLOAD_PICKLE environment variable is explicitly set to an enabling value. The vendor states updating (with pickle auto-loading disabled by default) is the fix; opting back in via LABBENCH_AUTOLOAD_PICKLE re-enables the dangerous behavior for trusted files only.

Impact

Signals are moderate and internally consistent, pointing to a real-but-conditional risk rather than an internet-facing emergency. The provided CVSS 4.0 vector is AV:L/AC:L/AT:N/PR:N/UI:P/VC:H/VI:H/VA:H (score 8.5), meaning the vector is local and requires user interaction (a user must load a crafted file) even though no privileges are needed; the high VC/VI/VA reflects that successful unpickling yields arbitrary code execution. No EPSS score was supplied and the CVE is not listed in CISA KEV, so there is no evidence of active or widespread exploitation; the mechanism (pickle deserialization) is trivially weaponizable but still depends on social engineering to get a victim to open a malicious .p/.pickle file. The vuln.today priority is 'this_week' (not act_now/emergency), a patch exists (0.46.1), and the issue was reported by VulnCheck with source-level confirmation. Net: a genuinely high-severity code-execution bug whose real-world urgency is tempered by the local attack vector and required user interaction and the niche deployment footprint of labbench. EPSS and KEV data are absent rather than low - treat exploitation likelihood as unquantified, not confirmed-benign.

Exploit ScenarioDerived

An attacker distributes a malicious data file or relational data archive containing a crafted pickle payload (e.g. shared as experiment data, a dataset, or a results archive). When a researcher loads it in labbench with read() or read_relational(), labbench auto-dispatches any .p/.pickle file to pandas.read_pickle by extension alone, executing the attacker's embedded Python code with the victim's privileges. No public exploit was identified in the provided data, but pickle code-execution payloads are trivial to construct and the trigger path is confirmed in the source diff.

This Week Schedule remediation this week. Why: HIGH severity (CVSS 7.0-8.9).
Patch available 0.1% exploitation probability (EPSS)

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

Alert me

AnalysisAIv1 – Nov 03, 2026

Deserialization of untrusted data in labbench before 0.46.1 allows arbitrary code execution when a user loads a crafted .p or .pickle file through read() or read_relational(). The library's auto-format dispatch selected pandas.read_pickle on the file extension alone, so a malicious pickle file - or a relational data archive containing one - runs attacker-controlled code with the permissions of the loading user. Exploitation requires user interaction (the victim must open the supplied file), the vector is local rather than network-facing, and no public exploit has been identified at time of analysis; the vendor fixed the behavior in 0.46.1 by refusing pickle auto-loading unless the LABBENCH_AUTOLOAD_PICKLE environment variable is explicitly set.

RemediationAI

Upgrade to labbench 0.46.1 or later (pip install --upgrade labbench==0.46.1) - this is the vendor's stated fix: read() and read_relational() now refuse .p/.pickle files unless the LABBENCH_AUTOLOAD_PICKLE environment variable is set to a value other than 0/false/no/off, and a refused load raises RuntimeError pointing at that variable. Do not set LABBENCH_AUTOLOAD_PICKLE in environments that process untrusted data; enabling it restores the dangerous unpickling behavior for any file whose name ends in .p or .pickle, so scope it only to workflows handling files you trust (the variable is process-wide, so an opted-in job can still be steered into loading a hostile file). On versions older than 0.46.1 where upgrading is not immediately possible, treat every .p/.pickle file - and every relational data archive that may contain one - as executable content: validate provenance out of band, keep the files away from automated pipelines, and prefer alternative formats such as CSV, JSON, feather or sqlite, which read() also supports and which do not execute code on load. Fix references: https://github.com/usnistgov/labbench/pull/32, https://github.com/usnistgov/labbench/commit/ac9b9b18cba67cb8e85eb563b6bb7dc1092b4c54, and https://github.com/usnistgov/labbench/blob/0.46.1/ChangeLog.md.

Affected VersionsENISA

labbench 0 <0.46.1

Affected Packages

euvd labbench fix: 0.46.1

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

labbench is a Python data-handling library published by NIST (usnistgov/labbench, distributed on PyPI). Its read() function guesses a file format from the extension and routes known extensions to the corresponding pandas loader; before 0.46.1 the dispatch table mapped both 'p' and 'pickle' directly to pandas.read_pickle (the vulnerable mapping is visible at src/labbench/_data.py#L1664-L1666 in the 0.46.0 tag). Python's pickle format is executable by design - unpickling invokes arbitrary object constructors via __reduce__ - so the extension-only dispatch means trust is granted purely on the basis of a filename, which is CWE-502 (Deserialization of Untrusted Data). read_relational() inherits the same exposure because a relational data archive can contain an entry with a pickle extension that is handed to the same code path. The upstream fix (PR #32, commit ac9b9b18cba67cb8e85eb563b6bb7dc1092b4c54) introduces a labbench.read_pickle wrapper that reads the LABBENCH_AUTOLOAD_PICKLE environment variable, treats unset, empty, '0', 'false', 'no' and 'off' as disabled, and raises RuntimeError otherwise before delegating to pandas.read_pickle; the new tests exercise both guessed and explicit 'pickle' formats and confirm the wrapper also enforces the opt-in. The trigger is loading a file with the affected functions; nothing in the available evidence indicates a network-triggered or pre-authentication path.

Know when Labbench 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.5 HIGH
CVSS:4.0/AV:L/AC:L/AT:N/PR:N/UI:P/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N
vuln.today AI 7.8 HIGH

AV:L and UI:R because the victim must locally load an attacker-supplied pickle file; PR:N as no authentication is required; unpickling yields full code execution so 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:P/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
Passive
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

labbench before 0.46.1 contains a deserialization of untrusted data vulnerability in read() and read_relational() that passes any file with a .p or .pickle extension to pandas.read_pickle based on the extension alone. Attackers who supply a crafted data file or relational data archive can execute arbitrary code when a user loads it with these functions.

Executive ViewAI

Why It Matters

CVE-2026-120833 affects the labbench Python library, allowing arbitrary code execution when a user opens a malicious .p or .pickle file through the read() or read_relational() functions. This poses a risk to data science and research teams who routinely load third-party datasets, as a single crafted file could compromise the user's workstation and any connected systems. Leadership should prioritize remediation because affected teams may be exposed through routine data ingestion workflows.

Business Impact: High
Compensating Controls

Apply vendor patch. If patching is delayed, ensure the LABBENCH_AUTOLOAD_PICKLE environment variable is unset, as version 0.46.1 introduces this safeguard by refusing pickle auto-loading unless explicitly enabled.

Threat Intelligence Overview

EPSS Score
0.1%
Top 96% exploitable
Prevalence
Low
niche NIST lab-instrument automation Python library, limited research footprint
Social Media
2
Sightings
Data Quality
4 sources
Confidence: Medium

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 Yes
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· derived
Scheduled
Exploitation· derived
None
System Exposure· derived
Small
Automatable· derived
No
Human Impact
High

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.

Remote Code Execution represents the critical moment when an attacker successfully runs arbitrary code on a target system without physical access.

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