/

CVE-2026-10043

Severity:

HIGH RISK

(7.8)

Unsafe Deserialization (CWE-502) in MosaicML Composer

CVE-2026-10043

Awaiting Analysis

Vulnerability type

Category:

Unsafe Deserialization

CWE:

CWE-502

Impact:

Remote Code Execution in Application Context

Severity:

HIGH RISK

(7.8)

CVSS version:

3.0

Catch this CVE while code is being written

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

Summary

MosaicML Composer contains an unsafe deserialization vulnerability in its checkpoint parsing logic, allowing arbitrary code execution during load operations.

If a user opens a malicious checkpoint file or visits a page that triggers Composer to load untrusted data, an attacker can execute code in the context of the current process.

Affected context

The vulnerability occurs when MosaicML Composer loads and parses checkpoints that originate from untrusted or unverified sources.

It is most relevant in workflows where models, training states, or checkpoints are shared between users or downloaded from external locations.

Risk increases when Composer is integrated into automated pipelines, notebooks, or tools that transparently load user-provided checkpoint files without additional validation.

Exploit preconditions

  • Attack surface: Checkpoint loading functionality in MosaicML Composer
  • Required access: Ability to provide or influence the checkpoint file or data being parsed
  • User interaction: A user must open, import, or otherwise cause Composer to load the malicious checkpoint (e.g., via a notebook, script, or UI)
  • Trigger point: Deserialization of checkpoint contents during restore or load operations
  • Why exploitation is possible: Composer deserializes user-supplied checkpoint data without sufficient validation or restriction, allowing attacker-controlled objects or structures to execute code at load time

Why this happens

The core issue is unsafe deserialization of attacker-controlled data, mapped to CWE-502: Deserialization of Untrusted Data.

Composer's checkpoint parsing logic trusts the structure and content of checkpoint files and uses general-purpose serialization mechanisms that can reconstruct complex objects.

When these mechanisms operate on untrusted data, object constructors or special hooks may run during deserialization, allowing embedded logic to execute within the current process.

Potential impact

  • Execution of arbitrary code within the MosaicML Composer process
  • Theft or corruption of training data, model weights, or experiment configuration
  • Installation of backdoors or logic changes into ML training and evaluation workflows
  • Lateral movement within the environment if the Composer process has broad access to files, credentials, or network resources
  • Manipulation of model behavior, leading to data poisoning or biased outputs

General mitigation guidance

Effective mitigation focuses on limiting trust in serialized inputs and hardening deserialization paths.

Common defensive patterns include:

  • Avoiding general-purpose, code-executing deserialization APIs for checkpoints; prefer structured formats (e.g., JSON, protocol buffers, or restricted binary formats) that do not reconstruct arbitrary objects
  • Implementing strict schema validation for checkpoint contents and rejecting unexpected fields or object types
  • Treating externally provided checkpoints as untrusted, and isolating their processing (e.g., sandboxing, reduced privileges, or separate processes)
  • Running Composer and associated tooling with least-privilege filesystem and network access to reduce impact if deserialization is abused
  • Encouraging workflows and policies that restrict loading of checkpoints from unknown or unauthenticated sources

How teams detect issues like this

Detection typically involves a combination of code-centric and process-centric controls:

  • Static analysis rules that flag uses of unsafe serialization/deserialization APIs, especially where data originates from user-controllable files or network sources
  • Code review checklists that call out checkpoint parsing logic, reconstruction of complex objects, and any hooks executed during load operations
  • Runtime logging around checkpoint loading, including source locations, integrity checks, and anomalous object types or behaviors
  • Policy enforcement in CI/CD pipelines to block introduction of new unsafe deserialization patterns and require structured, schema-validated formats for persisted state
  • Periodic security testing of ML tooling to identify deserialization entry points and validate that they enforce strict type and schema constraints

Sources

SourceLink
github.comgithub.com/mosaicml/composer/commit/6405188805a0054b4551ec49e4919c54c971d0e8
zerodayinitiative.comzerodayinitiative.com/advisories/ZDI-26-384/

Frequently asked

questions

Yes, but indirectly. An attacker must convince a user or system to load a malicious checkpoint file, which can be delivered over the network or via a compromised repository. Exploitation occurs when Composer deserializes the attacker-controlled data.

An attacker needs the ability to influence the checkpoint data that Composer will load. This typically means hosting or providing a malicious checkpoint file or content that a user or automated process then opens or imports.

The safest approach is to eliminate unsafe deserialization by using non-executable, structured formats for checkpoints and enforcing strict schema and type validation, so loading a checkpoint cannot trigger arbitrary object construction or code execution.

Design checkpoint and model persistence mechanisms around simple, declarative data formats, enforce clear trust boundaries for any external artifacts, apply static analysis and code review to serialization logic, and run ML workloads with least privilege so that any parsing flaws have minimal impact.

Find out what's already
exploitable in your codebase.