Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessCraft malicious WebDataset tar with pickled payload
-
DeliveryDeliver archive into dataset source
-
ExploitVictim job calls read_webdataset()
-
Execution_default_decoder runs pickle.loads/torch.load
-
PersistArbitrary code executes on Ray workers
-
ImpactCluster compromise
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A08:2025 - Software or Data Integrity Failures
ASVS 5.0
V1 - Encoding and Sanitization Safe deserialization, type allowlists
MITRE ATT&CK
2 techniques across 2 tactics: Execution, Initial Access The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up. |
| Exploitation Conditions | Exploitation requires that a Ray Data pipeline actually invokes read_webdataset() and processes an attacker-supplied tar archive containing an entry with a .pkl, .pickle, .pt, or .pth extension - this maps to the CVSS UI:A (active user interaction) requirement, meaning a victim or automated job must ingest the malicious archive. No authentication is needed against Ray itself (PR:N) and no special Ray configuration is required beyond use of the WebDataset reader, which is the default decoder behavior for that datasource. The primary limiting factor is data provenance: if the cluster only reads WebDataset archives from trusted, internally-controlled sources, an attacker has no delivery channel; the vulnerability becomes exploitable specifically when untrusted, externally-sourced, or user-uploaded datasets are fed into the reader. Affected only on Ray versions prior to 2.56.0. |
| Impact | The supplied CVSS 4.0 score is 8.6 with vector AV:N/AC:L/AT:N/PR:N/UI:A/VC:H/VI:H/VA:H, meaning network-reachable, low-complexity, no privileges, but requiring active user interaction (a victim/pipeline must actually ingest the attacker's archive) with full confidentiality, integrity and availability impact and no scope change to other systems. No EPSS score, KEV entry, or public POC was provided, so exploitation probability cannot be quantified from the input - the risk is driven by the deserialization primitive itself, which is reliably weaponizable once the archive is processed. The UI:A requirement is the key limiting factor: this is not autonomous internet-wide RCE but rather a supply-chain / untrusted-data-ingestion risk. For teams running Ray Data pipelines that consume externally-sourced or user-uploaded WebDataset archives this is a genuine high priority; for clusters that only process trusted, internally-generated datasets the practical risk is materially lower. Note: only a CVSS 4.0 vector was provided (no 3.1 vector and no EPSS/KEV signals), so cross-signal corroboration is limited. |
| Exploit ScenarioDerived | An attacker crafts a WebDataset tar archive containing a .pkl (or .pt) entry whose serialized payload runs a shell command via pickle's __reduce__ mechanism, then gets it into a data pipeline - for example by uploading it to a shared dataset bucket or publishing it as a public training set. When a Ray Data job calls read_webdataset() on that archive, _default_decoder() deserializes the entry and the attacker's code executes on every Ray worker that processes the shard. No public exploit code was identified at time of analysis, but the technique is standard and reliable given the low attack complexity (AC:L). |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Jul 01, 2026
Remote code execution in Ray (the distributed compute/ML framework) before version 2.56.0 lets attackers run arbitrary code by feeding a malicious tar archive to the WebDataset reader. The read_webdataset() datasource invokes pickle.loads() on .pkl/.pickle entries and torch.load() with weights_only=False on .pt/.pth entries with no validation, so code executes inside every Ray remote worker that processes the archive. No public exploit has been identified at time of analysis, but the fix is available in Ray 2.56.0 and the issue is documented in a GitHub Security Advisory (GHSA-hhrp-gw25-jr43) and a VulnCheck advisory.
RemediationAI
Vendor-released patch: upgrade to Ray 2.56.0 or later, which contains the fixes from pull requests https://github.com/ray-project/ray/pull/63469 and https://github.com/ray-project/ray/pull/63470. If immediate upgrade is not possible, do not use read_webdataset() to ingest archives from untrusted or externally-controlled sources, and restrict WebDataset inputs to datasets you generate and store yourself; treat any third-party or user-uploaded tar shards as executable code. As a compensating control, avoid or strip .pkl/.pickle/.pt/.pth entries from incoming archives and source datasets only from trusted, integrity-verified storage - the trade-off is that legitimate pickled or PyTorch-serialized samples in those datasets will no longer load, which may break existing pipelines. Refer to the advisory at https://github.com/ray-project/ray/security/advisories/GHSA-hhrp-gw25-jr43 for authoritative guidance.
Affected VersionsENISA
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 1 package in pypi
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
The root cause is CWE-502 (Deserialization of Untrusted Data). Ray Data's WebDataset integration reads sharded datasets packaged as tar archives, a common format in large-scale ML training pipelines. The vulnerable code path is _default_decoder() in webdataset_datasource.py, which dispatches decoding by file extension: entries ending in .pkl/.pickle are passed straight to Python's pickle.loads(), and .pt/.pth entries are loaded via PyTorch's torch.load() with weights_only=False. Both pickle and unrestricted torch.load reconstruct arbitrary Python objects and can execute code through __reduce__ during unpickling, so any attacker-controlled bytes in those entries become code execution. Because Ray distributes dataset reading across remote workers, the malicious payload runs on each worker node that touches the archive, amplifying impact across the cluster.
Know when Ray 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
CVSS:4.0/AV:N/AC:L/AT:N/PR:N/UI:A/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N
Network-reachable data reader with no auth (PR:N) but a victim must ingest the malicious archive (UI:R); pickle deserialization yields full code execution, hence C/I/A:H and scope unchanged.
Primary rating from Vendor (vulncheck).
CVSS VectorVendor: vulncheck
Lifecycle Timeline
1DescriptionCVE.org
Ray prior to 2.56.0 contains an unsafe deserialization vulnerability in the WebDataset reader that allows attackers to achieve remote code execution by supplying a malicious tar archive to the read_webdataset() function. The _default_decoder() function in webdataset_datasource.py unconditionally calls pickle.loads() on tar entries with .pkl/.pickle extensions and torch.load() with weights_only=False on .pt/.pth entries, executing arbitrary code inside Ray remote workers on every worker that processes the malicious archive.
Executive ViewAI
Remote code execution vulnerability in Ray distributed computing framework (versions before 2.56.0) allows attackers to execute arbitrary code on remote workers through malicious tar archives processed by the WebDataset reader; no public exploit identified at time of analysis. Organizations using Ray for ML workloads or distributed data processing face risk of worker process compromise and data exfiltration. Immediate upgrade to Ray 2.56.0 is required to eliminate this critical infrastructure threat.
Apply vendor patch: Ray 2.56.0. Interim mitigation pending upgrade: restrict access to WebDataset reader functionality and disable automated tar archive processing from untrusted data sources.
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
Insecure deserialization occurs when an application converts serialized data (a stream of bytes representing an object's state) back into a living object without proper validation.
Remote Code Execution represents the critical moment when an attacker successfully runs arbitrary code on a target system without physical access.
Ray is an AI compute engine. Rated critical severity (CVSS 9.4), this vulnerability is remotely exploitable, no authenti
A command injection existed in Ray's cpu_profile URL parameter allowing attackers to execute os commands on the system r
Anyscale Ray 2.6.3 and 2.8.0 allows /log_proxy SSRF. Rated critical severity (CVSS 9.1), this vulnerability is remotely
Local file disclosure in the Ray Dashboard (default TCP port 8265) of the Ray distributed-computing framework affects al
LFI in Ray's /static/ directory allows attackers to read any file on the server without authentication. Rated high sever
LFI in Ray's log API endpoint allows attackers to read any file on the server without authentication. Rated high severit
Ray dashboard versions 2.53.0 and below lack proper authentication on DELETE endpoints, allowing unauthenticated attacke
EUVD-2026-41089
GHSA-hhrp-gw25-jr43
NVD
CVE.org
EPSS
Vulnrichment
Exploit-DB