Skip to main content

Ray CVE-2026-57516

| EUVDEUVD-2026-41089 HIGH
Deserialization of Untrusted Data (CWE-502)
2026-07-01 disclosure@vulncheck.com GHSA-hhrp-gw25-jr43 PYSEC-2026-2273
8.6
CVSS 4.0 · Vendor: vulncheck
View

Attack ChainAIDerived

Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain

  1. Access
    Craft malicious WebDataset tar with pickled payload
  2. Delivery
    Deliver archive into dataset source
  3. Exploit
    Victim job calls read_webdataset()
  4. Execution
    _default_decoder runs pickle.loads/torch.load
  5. Persist
    Arbitrary code executes on Ray workers
  6. Impact
    Cluster 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).

This Week Schedule remediation this week. Why: HIGH severity (CVSS 7.0-8.9).
Patch available 0.5% exploitation probability (EPSS)

Get an e-mail when this CVE is exploited, patched or re-scored. Free account.

Alert me

AnalysisAIv1 – 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

ray 0 <2.56.0

Affected Packages

pypi ray fix: 2.56.0

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

Vendor (vulncheck) PRIMARY 8.6 HIGH
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
vuln.today AI 8.8 HIGH

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.

3.1 AV:N/AC:L/PR:N/UI:R/S:U/C:H/I:H/A:H
4.0 AV:N/AC:L/AT:N/PR:N/UI:A/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N
Red Hat 8.8 HIGH

Primary rating from Vendor (vulncheck).

CVSS VectorVendor: vulncheck

Attack Vector
Network
Attack Complexity
Low
Attack Requirements
None
Privileges Required
None
User Interaction
Active
Vulnerable system: Confidentiality
High
Vulnerable system: Integrity
High
Vulnerable system: Availability
High
Subsequent system: Confidentiality
None
Subsequent system: Integrity
None
Subsequent system: Availability
None

Lifecycle Timeline

1
Patch available
Jul 01, 2026 - 18:02 EUVD

DescriptionCVE.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

Why It Matters

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.

Business Impact: High
Compensating Controls

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

EPSS Score
0.5%
Top 62% exploitable
Prevalence
Medium
widely used ML/distributed-compute framework, not universal outside AI infrastructure
Threat Intel
1
1 source
Exploit
POC
Public exploit code exists
Data Quality
7 sources
Confidence: High
EUVD NVD CVE.org EPSS Vulnrichment GHSA Vendor GitHub

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.

SignalValue
Severity HIGH
CISA KEV No
Public POC Yes
EPSS 0.5%
Patch available Yes
Active threat No
Deciding rule
HIGH severity (CVSS 7.0-8.9)
What every action level means
Emergency Immediate action required. Criteria: CRITICAL + in CISA KEV (actively exploited) without patch, OR CRITICAL + EPSS > 30% without patch, OR CRITICAL + active threat signals without patch.
Act Now Prioritize within 24-48h. Criteria: in KEV with patch available, OR CRITICAL + public POC, OR HIGH + EPSS > 10%, OR CRITICAL + active threat, OR any CRITICAL severity.
This Week Schedule remediation this week. Criteria: HIGH severity (CVSS 7.0-8.9). Patch within normal change window.
This Month Plan within 30 days. Criteria: MEDIUM severity (CVSS 4.0-6.9), lower exploitation probability. Include in regular patch cycle.
Monitor Track and reassess. Criteria: LOW severity (CVSS 0.1-3.9), minimal exploitation risk. No immediate action needed.

SSVC AssessmentENISA

SSVC Decision
Scheduled
Exploitation
Poc
System Exposure· derived
Open
Automatable
No
Human Impact
High
Technical Impact
Total

Priority Score

63
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +43
PoC: +20
Weaponized: 0
Threat intel: 0
Gov advisory: 0

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.

Vendor StatusVendor

This site uses cookies essential for authentication and security. No tracking or analytics cookies are used. Privacy Policy