Skip to main content

fickling CVE-2026-14534

| EUVDEUVD-2026-41675 HIGH
Incomplete List of Disallowed Inputs (CWE-184)
2026-07-04 BombadilSystems GHSA-v8cr-9jrc-fwf9
8.8
CVSS 3.1 · Vendor: BombadilSystems
View

Attack ChainAIDerived

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

  1. Access
    Craft pickle using _posixsubprocess.fork_exec
  2. Delivery
    Distribute as untrusted model file
  3. Exploit
    Victim runs fickling check_safety()
  4. Execution
    Scanner returns LIKELY_SAFE verdict
  5. Persist
    fickling.load() deserializes payload
  6. Impact
    Arbitrary binary executed on host

Vulnerability Assessment

Weakness
CWE
OWASP Top 10:2025
A05:2025 - Injection
ASVS 5.0
V2 - Validation and Business Logic Input validation completeness
Exploitation Conditions

Exploitation requires that the victim use a vulnerable fickling version (≤ 0.1.10) to scan or load an attacker-controlled pickle - the pickle must import one of the three un-denylisted stdlib modules (_posixsubprocess for fork_exec, site for execsitecustomize, or atexit for _run_exitfuncs) to achieve code execution while still receiving a LIKELY_SAFE verdict. Reliable bypass of the UnusedVariables heuristic additionally depends on the SETITEMS opcode pattern noted in the advisory. The limiting factor is the required user interaction (CVSS UI:R): the attack only fires when someone actively runs fickling's safety check or fickling.load() on the malicious file, so no exploitation occurs against a host that never processes the hostile pickle; no authentication is needed (PR:N) and the vector is network-deliverable since the pickle can be distributed as a model file.

Impact

The CVSS 3.1 vector (AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H, base 8.8) reflects a network-deliverable, low-complexity, unauthenticated attack that requires user interaction - specifically, a victim must scan or load an attacker-supplied pickle with fickling. That user-interaction requirement is the primary limiter: this is not a wormable remote-service flaw but a defense bypass that fires when the defensive tool itself processes hostile input, which is precisely fickling's intended use case (analyzing untrusted ML model files), so the UI:R condition is easily satisfied in practice. No EPSS score, KEV listing, or POC flag is present in the provided intelligence, so exploitation probability cannot be quantified from the data; the detailed public advisory (GHSA-m6fh-58r7-x697) and named exploit primitives nonetheless lower the barrier to weaponization even though no exploit code is confirmed. This is a genuine priority for anyone relying on fickling as a security gate, because a false LIKELY_SAFE verdict actively converts a protective control into an execution path - but it is not evidence of widespread active exploitation. No SSVC decision data was supplied.

Exploit ScenarioDerived

An attacker publishes a malicious ML model (e.g., a PyTorch/pickle artifact) to a model hub or supplies it to a victim who uses fickling to vet untrusted pickles. The victim runs fickling.load() or check_safety() on the file; because the payload uses _posixsubprocess.fork_exec, fickling reports LIKELY_SAFE and then deserializes it, executing an arbitrary binary on the victim's host. No public exploit code is identified at time of analysis, but the advisory names the exact bypass primitives, making weaponization straightforward.

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

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

Alert me

AnalysisAIv1 – Jul 04, 2026

Arbitrary code execution bypass in Trail of Bits fickling (versions ≤ 0.1.10) allows attackers to craft malicious pickle files that the tool's check_safety() gate rates LIKELY_SAFE with zero findings. Because the standard-library modules _posixsubprocess, site, and atexit are missing from the UNSAFE_IMPORTS denylist in fickle.py, payloads invoking _posixsubprocess.fork_exec, site.execsitecustomize, or atexit._run_exitfuncs pass the scanner and are then deserialized and executed by fickling.load(), which chains check_safety() into pickle.loads() as its security gate. No public exploit has been identified at time of analysis, and no EPSS or KEV signals are present in the input, but the advisory documents the exact bypass primitives.

RemediationAI

Vendor-released patch: upgrade fickling to v0.1.11 or later (https://github.com/trailofbits/fickling/releases/tag/v0.1.11), which adds the missing modules to the denylist per PR https://github.com/trailofbits/fickling/pull/272 and commit e8408615b63adf034f891f653692ab9b51f0f5af; review the advisory at https://github.com/trailofbits/fickling/security/advisories/GHSA-m6fh-58r7-x697. If immediate upgrade is not possible, do not treat a LIKELY_SAFE verdict from vulnerable versions as authoritative for untrusted pickles - route all untrusted model files through isolation (deserialize only inside a sandboxed, network-restricted, least-privileged container or ephemeral VM) so a missed detection cannot spawn processes on a trusted host, accepting the operational overhead of sandbox provisioning. As a stopgap you may extend the local UNSAFE_IMPORTS denylist to include _posixsubprocess, site, and atexit, but this is fragile because the same class of gap has recurred (cProfile, pty, marshal/types) and hand-maintained denylists are inherently incomplete; prefer the upstream fix.

Affected VersionsENISA

fickling 0 ≤0.1.10

Affected Packages

pypi fickling fix: 0.1.11

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

fickling is a Python pickle security-analysis and safe-loading library that inspects pickle bytecode and classifies payloads (SAFE / LIKELY_SAFE / LIKELY_UNSAFE) before optionally deserializing them. Its defense is a denylist model - UNSAFE_IMPORTS in fickle.py enumerates dangerous importable modules that the UnsafeImports heuristic flags. The root cause is CWE-184 (Incomplete List of Disallowed Inputs): three exploitable stdlib modules were never added to the denylist, so _posixsubprocess.fork_exec (a C-level process spawner that executes arbitrary binaries), site.execsitecustomize (runs arbitrary site-customization code), and atexit._run_exitfuncs (fires registered exit handlers) are treated as benign. Complementary heuristics also fail to compensate: OvertlyBadEvals ignores them because they are stdlib imports, UnsafeImports ignores them because they are absent from the denylist, and the UnusedVariables heuristic is defeated by the SETITEMS opcode pattern. The affected package is identified by cpe:2.3:a:trailofbits:fickling:*:*:*:*:*:*:*:*, and the advisory notes the same root cause as CVE-2026-22607 (cProfile), CVE-2025-67748 (pty), and CVE-2025-67747 (marshal/types), indicating a recurring denylist-completeness weakness in this tool.

Know when Fickling 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 (BombadilSystems) PRIMARY 8.8 HIGH
AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H
vuln.today AI 8.8 HIGH

Attacker-supplied pickle is network-deliverable (AV:N) and needs no auth (PR:N), but a victim must run the scanner/loader on it (UI:R); a successful bypass yields full RCE (C/I/A:H).

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

Primary rating from Vendor (BombadilSystems).

CVSS VectorVendor: BombadilSystems

Attack Vector
Network
Attack Complexity
Low
Privileges Required
None
User Interaction
Required
Scope
Unchanged
Confidentiality
High
Integrity
High
Availability
High

DescriptionCVE.org

Trail of Bits fickling versions up to and including 0.1.10 do not include the Python standard library modules _posixsubprocess, site, and atexit in the UNSAFE_IMPORTS denylist (fickle.py). Because these modules are absent from the denylist, fickling's check_safety() function returns LIKELY_SAFE with zero findings for pickle payloads that invoke dangerous functions including _posixsubprocess.fork_exec (C-level process spawner capable of executing arbitrary binaries), site.execsitecustomize (executes arbitrary site customization code), and atexit._run_exitfuncs (triggers all registered exit handler callbacks). The fickling.load() API chains check_safety() into pickle.loads() as an explicit security gate; a LIKELY_SAFE verdict causes the payload to be deserialized and executed. This shares the same root cause as CVE-2026-22607 (cProfile), CVE-2025-67748 (pty), and CVE-2025-67747 (marshal/types). OvertlyBadEvals does not flag these modules because they are standard library imports. UnsafeImports does not flag them because they are not in the denylist. The UnusedVariables heuristic is defeated by the SETITEMS opcode pattern.

Executive ViewAI

Why It Matters

Trail of Bits fickling (versions ≤0.1.10) contains a logic flaw in its pickle deserialization safety validation that allows attackers to execute arbitrary code while bypassing the library's security controls; no public exploit identified at time of analysis. Any organization using fickling to validate pickle files from untrusted sources faces remote code execution risk with no available vendor patch. This directly undermines the primary security purpose of the library and requires immediate remediation.

Business Impact: Severe
Compensating Controls

No vendor-released patch identified at time of analysis. Interim mitigations: (1) Discontinue processing untrusted pickle input with fickling; (2) Restrict deserialization to isolated, network-disconnected environments; (3) Migrate to alternative serialization formats (JSON, Protocol Buffers); (4) Monitor Trail of Bits GitHub repository and security advisories for patch releases.

Threat Intelligence Overview

EPSS Score
0.3%
Top 75% exploitable
Prevalence
Low
niche ML pickle-security library, used mainly by ML security practitioners
Social Media
2
Sightings
Data Quality
8 sources
Confidence: High
EUVD NVD CVE.org EPSS Vulnrichment Vendor CIRCL 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.3%
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
Out-of-Cycle
Exploitation
Poc
System Exposure· derived
Open
Automatable
No
Human Impact
Very High
Technical Impact
Total

Priority Score

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

Attack Technique

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

CVE-2026-22607 HIGH POC
7.8 Jan 10

Fickling's static analyzer through version 0.1.6 fails to properly classify the cProfile module as unsafe during pickle

CVE-2026-22606 HIGH POC
7.8 Jan 10

Fickling's incomplete pickle analysis allows attackers to bypass security checks by using Python's runpy module to execu

CVE-2026-22609 HIGH POC
7.8 Jan 10

Fickling's static analyzer before version 0.1.7 fails to detect several dangerous Python modules in pickled objects, ena

CVE-2025-67748 HIGH POC
7.1 Dec 16

Trail of Bits Fickling versions before 0.1.6 fail to flag malicious pickles as unsafe because the `pty` module was omitt

CVE-2025-67747 HIGH POC
7.1 Dec 16

Deserialization of an attacker-supplied pickle file that has been vetted by Fickling versions prior to 0.1.6 can execute

CVE-2026-14535 CRITICAL
9.8 Jul 04

Security-control bypass in Trail of Bits fickling (≤0.1.11) neuters its MLAllowlist analysis pass so that malicious pick

CVE-2026-118938 HIGH
8.8 Oct 30

Pickle-analysis bypass in Trail of Bits fickling through 0.1.12 and vendor master commit d011709 allows arbitrary code e

CVE-2026-16760 HIGH
8.8 Oct 30

fickling through 0.1.12 misclassifies malicious pickle payloads as safe: its OvertlyBadEvals analysis pass skips any cal

CVE-2026-22612 HIGH
7.8 Jan 10

Fickling versions prior to 0.1.7 fail to properly detect malicious pickle payloads due to inadequate handling of the "bu

CVE-2026-22608 HIGH
7.8 Jan 10

Fickling before version 0.1.7 allows local attackers to achieve arbitrary code execution through Python pickle deseriali

Vendor StatusVendor

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