Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessCraft pickle using _posixsubprocess.fork_exec
-
DeliveryDistribute as untrusted model file
-
ExploitVictim runs fickling check_safety()
-
ExecutionScanner returns LIKELY_SAFE verdict
-
Persistfickling.load() deserializes payload
-
ImpactArbitrary 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. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – 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
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
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
AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H
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).
Primary rating from Vendor (BombadilSystems).
CVSS VectorVendor: BombadilSystems
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
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.
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
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
Remote Code Execution represents the critical moment when an attacker successfully runs arbitrary code on a target system without physical access.
Fickling's static analyzer through version 0.1.6 fails to properly classify the cProfile module as unsafe during pickle
Fickling's incomplete pickle analysis allows attackers to bypass security checks by using Python's runpy module to execu
Fickling's static analyzer before version 0.1.7 fails to detect several dangerous Python modules in pickled objects, ena
Trail of Bits Fickling versions before 0.1.6 fail to flag malicious pickles as unsafe because the `pty` module was omitt
Deserialization of an attacker-supplied pickle file that has been vetted by Fickling versions prior to 0.1.6 can execute
Security-control bypass in Trail of Bits fickling (≤0.1.11) neuters its MLAllowlist analysis pass so that malicious pick
Pickle-analysis bypass in Trail of Bits fickling through 0.1.12 and vendor master commit d011709 allows arbitrary code e
fickling through 0.1.12 misclassifies malicious pickle payloads as safe: its OvertlyBadEvals analysis pass skips any cal
Fickling versions prior to 0.1.7 fail to properly detect malicious pickle payloads due to inadequate handling of the "bu
Fickling before version 0.1.7 allows local attackers to achieve arbitrary code execution through Python pickle deseriali
EUVD-2026-41675
GHSA-v8cr-9jrc-fwf9
NVD
CVE.org
EPSS
Vulnrichment
VulDB
Exploit-DB