Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessCraft pickle with dotted __qualname__
-
DeliverySubmit to fickling-gated loading pipeline
-
ExploitBypass check_safety() / OvertlyBadEvals analysis
-
Executionoptparse.Values.read_file invokes exec()
-
ImpactArbitrary code execution on host
Vulnerability Assessment
| Weakness |
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Incorrectly specified target
|
| Exploitation Conditions | Exploitation requires the victim to run fickling (through 0.1.12, and the current master at commit d011709) as a trust gate - invoking fickling.load() or check_safety() on an attacker-supplied pickle and acting on its verdict. The crafted pickle must use a dotted __qualname__ that names a code-executing class method reachable via pickle's find_class/_getattribute (the advisory's concrete example is optparse.Values.read_file, available because optparse ships in all current CPython 3.x releases and is only deprecated, not removed, as of 3.13). No authentication is needed (PR:N) and the bypass works against default behavior - no special fickling configuration is required beyond relying on its LIKELY_SAFE result. The principal limiting factor is UI:R: the attack only fires when a victim actively loads/scans the malicious pickle through fickling, so environments that do not route untrusted pickles through fickling's safety check are not exposed by this specific weakness. |
| Impact | Severity is rated CVSS 8.8 (HIGH) with vector AV:N/AC:L/PR:N/UI:R, and CWE-706 (incorrectly-resolved name). The key framing: this is a detection-bypass flaw in a security tool, so the real-world harm is a false 'LIKELY_SAFE' verdict that causes a victim to load an attacker-controlled pickle they believed was vetted. The vuln.today decision label is 'this_week' - a near-term priority, not act_now/emergency. Exploitation signals are partly missing: no CISA KEV listing is present in the input, no EPSS probability was provided, and no confirmed working exploit code is referenced (only a third-party advisory from the reporter). These absences should not be read as 'low risk' - they are simply unmeasured here. The notable aggravating factor is persistence of the defect: the input states the bypass was verified still present on vendor master at commit d011709 as of 2026-10-30, surviving the October blocklist additions and the new private-stdlib-attribute heuristic (because optparse.Values.read_file is a public method, neither blocklisted nor private). So there is no complete fix available at analysis time, which raises practical concern for anyone using fickling as a gate. Net: a genuine this-week priority for fickling-dependent pipelines, tempered by the fact that it requires the victim to run fickling on hostile input (UI:R) and that no active-exploitation or EPSS evidence is available to confirm widespread targeting. |
| Exploit ScenarioDerived | An attacker crafts a malicious pickle whose STACK_GLOBAL operand uses a dotted __qualname__ such as 'optparse.Values.read_file', then submits it into a workflow that relies on fickling to screen untrusted pickles (for example an ML model-scanning pipeline). Fickling's check_safety() records only the leading name, renders it as a benign import, returns LIKELY_SAFE with zero findings, and fickling.load() then chains into pickle.loads(), causing optparse.Values.read_file to run exec(open(filename).read(), vars) and execute attacker-controlled code. No confirmed working exploit code is referenced in the input; a third-party advisory describing the technique exists. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 30, 2026
Pickle-analysis bypass in Trail of Bits fickling through 0.1.12 and vendor master commit d011709 allows arbitrary code execution when a victim uses fickling.load() or check_safety() as a safety gate on a crafted pickle, with CVSS 8.8 (AV:N/AC:L/PR:N/UI:R). The crafted pickle uses a dotted __qualname__ such as optparse.Values.read_file, which fickling records and renders as a plain import and never analyzes as a call, so OvertlyBadEvals does not flag it and check_safety() returns LIKELY_SAFE with zero findings while pickle resolution reaches a code-executing class method. No public exploit identified at time of analysis, and exploitation requires the victim to actively run fickling against the malicious pickle; the advisory states the bypass remained present on vendor master at commit d011709 as of 2026-10-30 and the vuln.today priority is this_week.
RemediationAI
No vendor-released patch identified at time of analysis; the advisory reports the bypass still present on vendor master at commit d011709 as of 2026-10-30, and no fixed release version is listed in the provided data. The vendor-side fix described is to resolve or flag dotted attribute-path imports in fickling's import tracking and analysis, which the advisory states is independent of CVE-2026-16760. Until a patched release appears, do not treat fickling.load() or check_safety() as an authoritative safety gate for attacker-supplied pickles and do not act on a LIKELY_SAFE result; scanning-only deployments should run fickling in a sandbox with no access to sensitive files and with exec and file-read restrictions, accepting that this may break legitimate scanning workflows. Blocking or removing the deprecated optparse module via an import hook can interrupt the specific optparse.Values.read_file chain but may break legacy CLI code and does not close other dotted attribute-path methods, so it is only a stopgap. Track https://github.com/trailofbits/fickling and https://bombadil.systems/advisories.html for a fixed release.
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 issue is CWE-706 (incorrectly-resolved name) in fickling's analysis of pickle import tracking. Pickle STACK_GLOBAL carries a module and a name, and pickle's find_class resolves the name through _getattribute, which splits dotted names, so a __qualname__ like 'Values.read_file' resolves to optparse.Values.read_file rather than a module-level function. Fickling records only the leading component 'Values' in its import tracking and renders the operation as 'from optparse import Values.read_file', so the trailing attribute reference is never analyzed as a call; the OvertlyBadEvals pass misses it and check_safety() returns LIKELY_SAFE with zero findings. optparse.Values.read_file executes exec(open(filename).read(), vars), so loading the crafted pickle through fickling.load(), which chains check_safety() into pickle.loads() as an explicit security gate, yields arbitrary code execution; optparse ships in all current CPython 3.x releases and is deprecated as of 3.13 but not removed. This weakness is distinct from and independently fixable from the module-origin trust weakness tracked as CVE-2026-16760: resolving or flagging dotted attribute-path imports closes this vector while leaving module-level trust behavior unchanged. The supplied diff for commit d011709 modifies PyTorch archive handling and CLI scanning rather than dotted-name resolution, consistent with the advisory's statement that the bypass remained present after the October blocklist additions and a new private-stdlib-attribute heuristic, because public Values.read_file is neither blocklisted nor treated as private.
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
Malicious pickle is delivered remotely (AV:N) with no auth (PR:N) but only executes when a victim loads it through fickling (UI:R); resulting exec() yields full code execution, so C/I/A all High.
Primary rating from Vendor (BombadilSystems).
CVSS VectorVendor: BombadilSystems
DescriptionCVE.org
In Trail of Bits fickling through 0.1.12, a pickle STACK_GLOBAL operand carrying a dotted __qualname__ (for example "Values.read_file") is resolved by pickle's find_class through _getattribute to an arbitrary attribute path rather than to a module-level function. Fickling records only the leading component of the name in its import tracking and renders the operation as a plain import (for instance, 'python -m fickling' displays it as 'from optparse import Values.read_file'), so the trailing attribute reference is never analyzed as a call. The OvertlyBadEvals analysis pass does not flag it, and check_safety() returns LIKELY_SAFE with zero findings. This allows an attacker to reach a class method that performs code execution: optparse.Values.read_file executes exec(open(filename).read(), vars), achieving arbitrary code execution when the crafted pickle is loaded through fickling.load(), which chains check_safety() into pickle.loads() as an explicit security gate. optparse is present in all current CPython 3.x releases (deprecated as of Python 3.13, not removed). This weakness is in the resolution and analysis of dotted attribute-path names, and is distinct from and independently fixable from the module-origin trust weakness tracked as CVE-2026-16760: resolving or flagging dotted attribute-path imports closes this vector while leaving the module-level trust behavior unchanged. This bypass was verified to remain present on the vendor master branch at commit d011709 as of 2026-10-30, after the vendor's October blocklist additions and a new heuristic that flags private stdlib attributes; because the public class method Values.read_file is neither blocklisted nor flagged as a private attribute, it is not addressed by those remediations.
Articles & Coverage 1
Executive ViewAI
CVE-2026-118938 is a high-severity flaw in Trail of Bits' fickling, a tool used to inspect Python pickle files for safety before loading them. If an employee uses fickling as a safety gate and then loads a malicious pickle, the tool can incorrectly report the file as safe, leading to arbitrary code execution on the victim's machine. Development and security teams that rely on fickling to screen third-party or untrusted pickle files are at risk, and a single successful exploit could compromise sensitive data or systems. Leadership should prioritize this because no patch is currently available and the tool's core safety guarantee is broken.
No vendor-released patch identified at time of analysis; interim mitigations include disabling fickling as a safety gate, sandboxing pickle processing, and treating all untrusted pickle files as malicious.
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
Arbitrary code execution bypass in Trail of Bits fickling (versions ≤ 0.1.10) allows attackers to craft malicious pickle
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-114515
GHSA-6jfm-qx2v-27jg
NVD
CVE.org
EPSS
Exploit-DB