/

CVE-2026-68772

Severity:

HIGH RISK

(8.0)

Unsafe Deserialization (CWE-502) in ZenML Materializer

CVE-2026-68772

Received

Vulnerability type

Category:

Unsafe Deserialization

CWE:

CWE-502

Impact:

Remote Code Execution

Severity:

HIGH RISK

(8.0)

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

ZenML's CloudpickleMaterializer can deserialize a malicious artifact file from a shared artifact store without adequately restricting its contents. An attacker who can replace an artifact may cause arbitrary code execution when a user or pipeline materializes it.

Affected context

The vulnerability occurs in ZenML deployments that use the CloudpickleMaterializer with a shared artifact store and load stored artifacts through an unsanitized cloudpickle deserialization path. Risk depends on an attacker having write access to the artifact location and on another user or pipeline subsequently materializing the modified artifact.

Exploit preconditions

  • Attack surface: Shared artifact storage and the artifact materialization workflow
  • Required access: Write access sufficient to replace or modify a stored artifact file
  • Trigger point: A user or pipeline materializes the affected artifact
  • Why exploitation is possible: The application passes attacker-controlled serialized data to cloudpickle.load(), which can reconstruct objects and invoke embedded reduction behavior during deserialization

Why this happens

The underlying bug is the treatment of attacker-controlled cloudpickle data as trusted serialized state. Pickle-compatible formats can encode object reconstruction behavior, including callable execution through mechanisms such as __reduce__. Loading such data without a restricted format, trust boundary, or integrity control maps to CWE-502: Deserialization of Untrusted Data.

Potential impact

  • Arbitrary system commands may execute in the ZenML process environment
  • Application credentials, environment variables, or stored data could be exposed
  • Pipelines or workers could be compromised
  • Artifact contents may be poisoned or altered
  • An attacker could gain opportunities for lateral movement, depending on runtime privileges and network access

General mitigation guidance

Mitigation generally focuses on removing implicit trust from serialized artifacts and limiting the privileges of materialization workers.

Common defensive patterns include:

  • Prefer safe, non-executable serialization formats with explicit schemas
  • Use restricted deserialization mechanisms that cannot reconstruct arbitrary classes or callables
  • Verify artifact integrity and provenance before materialization
  • Enforce strong access controls and immutable or append-only policies for shared artifact stores
  • Separate artifact publication permissions from artifact consumption permissions
  • Run materialization workloads with least privilege, restricted network access, and minimal filesystem permissions
  • Treat artifacts from external or untrusted producers as untrusted input throughout the pipeline

How teams detect issues like this

Detection approaches commonly include:

  • Static analysis rules identifying pickle, cloudpickle, or equivalent unrestricted load operations
  • Code review checks for deserialization of data retrieved from shared stores or user-controlled locations
  • Repository policies requiring approved serialization formats and integrity verification
  • Runtime monitoring for unexpected process creation, command execution, or access to sensitive files by materialization workers
  • Artifact-store audit logging for unusual replacements, ownership changes, or writes to previously published artifacts
  • Automated security review tools that flag unsafe deserialization and excessive worker privileges

Sources

SourceLink
github.comgithub.com/zenml-io/zenml
github.comgithub.com/zenml-io/zenml/commit/bbf8496d049a7e23800bc31b87b10b4fefbebe18
github.comgithub.com/zenml-io/zenml/pull/5103
vulncheck.comvulncheck.com/advisories/zenml-remote-code-execution-via-cloudpicklematerializer

Frequently asked

questions

It can be exploitable across a network when an attacker can obtain write access to a shared artifact store and a reachable ZenML workflow later materializes the altered artifact. It is not necessarily exploitable through an unauthenticated public endpoint alone.

The key prerequisite is permission to replace or modify an artifact consumed by the CloudpickleMaterializer. The attacker also needs a victim user or pipeline to trigger materialization.

Avoid executable pickle-compatible formats for untrusted artifacts. Use a restricted, schema-validated format and verify artifact integrity and provenance before loading data.

Apply least-privilege access controls to artifact stores, separate publication from consumption permissions, monitor artifact changes, and run materialization workloads with minimal privileges and network access.

Find out what's already
exploitable in your codebase.