/

CVE-2026-22607

Severity:

HIGH RISK

(7.8)

Security Validation / Policy Bypass in Fickling Pickle

CVE-2026-22607

Analyzed

Vulnerability type

Category:

Security Validation / Policy Bypass

CWE:

CWE-184, CWE-502

Impact:

Security Control Bypass Leading to Remote Code Execution

Severity:

HIGH RISK

(7.8)

CVSS version:

3.1

Catch this CVE while code is being written

Detect vulnerable code directly in pull requests, so CVEs are fixed before merge.

Summary

Fickling, a Python pickle decompiler and static analyzer, incorrectly classifies pickles that invoke Python's cProfile module as only SUSPICIOUS instead of OVERTLY_MALICIOUS.

When users or products rely on Fickling's verdict to decide whether a pickle is safe to deserialize, this misclassification can enable execution of attacker-controlled code under the assumption that the payload is low-risk.

Affected context

This vulnerability affects environments that:

  • Use Fickling (≤ 0.1.6) as a security gate or trust signal for Python pickle analysis
  • Automatically or routinely deserialize pickles that Fickling does not classify as OVERTLY_MALICIOUS
  • Treat SUSPICIOUS results as acceptable, lower-risk, or safe enough to proceed

It is relevant to CI/CD pipelines, artifact scanners, malware analysis tooling, and applications that integrate Fickling as part of their deserialization safety checks rather than implementing independent sandboxing or strict deny-by-default policies.

Exploit preconditions

  • Attack surface: Any workflow that ingests and analyzes untrusted or semi-trusted Python pickles using Fickling as a security filter.
  • Required access: Ability to supply or influence a pickle file that will be scanned by Fickling and potentially deserialized afterward.
  • Trigger point: Fickling analyzes a malicious pickle that uses cProfile.run() (or equivalent cProfile invocations) and labels it SUSPICIOUS instead of OVERTLY_MALICIOUS.
  • Why exploitation is possible: The analyzer's classification logic does not treat cProfile as inherently unsafe, so payloads leveraging cProfile as an execution vector evade stricter blocking policies that apply to clearly malicious modules or opcodes.

Why this happens

The core issue is an incomplete or incorrect security policy in Fickling's static analysis and classification engine.

This maps to CWE-184: Incomplete List of Disallowed Inputs, where the tool's denylist or risk model fails to include all dangerous modules or behaviors—here, Python's cProfile module.

Because cProfile.run() can be used to execute arbitrary code under the hood, any pickle that invokes it should be treated as overtly malicious in a security context.

Instead, Fickling's rules classify such payloads merely as SUSPICIOUS, creating a semantic gap between real execution risk and the reported severity.

In the broader context of CWE-502: Deserialization of Untrusted Data, this misclassification weakens an upstream safeguard that is intended to prevent unsafe deserialization, effectively undermining defense-in-depth.

Potential impact

  • Attackers can craft pickles that leverage cProfile.run() to execute arbitrary Python code while appearing only SUSPICIOUS in Fickling.
  • Automated systems may proceed to deserialize these payloads assuming they are not overtly malicious.
  • Users and analysts may underestimate the risk of such pickles, leading to manual execution or loading in trusted environments.
  • Security workflows that depend heavily on Fickling's classification may experience a silent policy bypass, reducing overall detection and blocking effectiveness.
  • Downstream compromise of developer machines, CI workers, or application servers that deserialize attacker-supplied pickles based on Fickling's assessment.

General mitigation guidance

Effective mitigation focuses on strengthening both the classification model and the overall deserialization posture:

  • Treat deserialization of untrusted Python pickles as inherently high-risk, regardless of external scanner classification, and prefer safer data formats (e.g., JSON, MessagePack, or domain-specific encodings) where feasible.
  • Implement a deny-by-default policy for dangerous modules, builtins, and execution primitives; include modules like cProfile in "unsafe by default" sets within analysis and gating tools.
  • Use multiple, independent signals for security decisions: pair static analysis tools like Fickling with sandboxing, separate execution environments, or manual review for high-risk sources.
  • Apply least privilege and isolation when processing pickles: run analysis and any necessary deserialization in tightly constrained containers or VMs with minimal OS and network access.
  • Encode organizational policy that "SUSPICIOUS" or "unknown" classifications are not automatically safe, and require additional checks or enforced blocking in automated pipelines.

How teams detect issues like this

Organizations can detect and monitor this class of weakness by:

  • Reviewing security tool configurations to ensure that modules capable of code execution (e.g., os, subprocess, cProfile, inspect, pickle hacks) are consistently treated as unsafe in both detection rules and policies.
  • Using static analysis on security tooling and integration code to identify incomplete deny lists or classification logic that omits known-dangerous modules.
  • Implementing policy tests or regression tests where crafted malicious pickles are run through the security pipeline to confirm they are blocked or flagged as high severity.
  • Incorporating security code review checklists that explicitly ask: "What assumptions are we making about tool classifications (SAFE / SUSPICIOUS / MALICIOUS), and what happens if any of them are wrong?"
  • Leveraging automated code review or SAST tools to highlight security gates that rely on string comparisons or partial lists of unsafe APIs, prompting human review of those assumptions.

Sources

SourceLink
github.comgithub.com/trailofbits/fickling/commit/dc8ae12966edee27a78fe05c5745171a2b138d43
github.comgithub.com/trailofbits/fickling/releases/tag/v0.1.7
github.comgithub.com/trailofbits/fickling/security/advisories/GHSA-p523-jq9w-64x9

Frequently asked

questions

Exploitability depends on how heavily a workflow trusts Fickling's classifications. If a system automatically deserializes pickles that are not marked OVERTLY_MALICIOUS, a crafted payload using cProfile.run() can realistically lead to arbitrary code execution.

An attacker must be able to supply or influence a pickle that will be analyzed by Fickling and later deserialized—this might be via file upload endpoints, artifact submission in CI, plugin ecosystems, or shared data exchanges between systems.

Strengthen the analysis policy so that modules and APIs capable of executing arbitrary code, such as cProfile, are treated as unsafe by default, and update workflows so that non-affirmatively-safe classifications (SUSPICIOUS, unknown, or error) are not automatically allowed to proceed to deserialization.

Avoid relying on a single tool's classification as the sole gate for deserialization, design policies around deny-by-default for untrusted pickles, expand and regularly review unsafe-module lists, and use layered defenses such as sandboxing, privilege separation, and safer serialization formats wherever possible.

Find out what's already
exploitable in your codebase.