/

CVE-2026-67260

Severity:

HIGH RISK

(7.3)

Unsafe Deserialization (CWE-502) in Airflow Scheduler

CVE-2026-67260

Analyzed

Vulnerability type

Category:

Unsafe Deserialization

CWE:

CWE-502

Impact:

Scheduler Process Compromise or Denial of Service

Severity:

HIGH RISK

(7.3)

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

Apache Airflow's scheduler deserializes human-in-the-loop task data without applying an appropriate class allow-list. A DAG author who can control the task execution data may cause arbitrary module imports and object instantiation in the scheduler process, or disrupt scheduler operation.

Affected context

The vulnerability affects Apache Airflow 3.3.0 deployments using human-in-the-loop tasks that transition into the awaiting_input state. During a periodic scheduler sweep, the task instance's next_kwargs value is deserialized without the expected allow-list, and the default allowed_deserialization_classes setting does not protect this code path. Earlier Airflow versions use a different triggerer-based workflow and are not affected by this specific path.

Exploit preconditions

  • Attack surface: Airflow task execution and scheduler processing
  • Required access: Ability to author or control a DAG and supply task execution data through the human-in-the-loop task API
  • Trigger point: Scheduler processing of an awaiting_input task during its periodic sweep
  • Why exploitation is possible: The scheduler deserializes attacker-influenced next_kwargs without enforcing an effective class allow-list, permitting module imports and object construction inside the scheduler process

Why this happens

The underlying flaw is unsafe deserialization of attacker-influenced task metadata. The scheduler treats serialized values as trusted object descriptions and processes them without restricting the classes or modules that may be resolved. This behavior maps to CWE-502: Deserialization of Untrusted Data, because deserialization can invoke object construction or related import behavior before the data is safely constrained.

Potential impact

  • An attacker may execute code or trigger unintended behavior in the scheduler process.
  • An attacker could terminate or destabilize the scheduler job.
  • Workflow scheduling and task coordination could be disrupted.
  • Scheduler-level access could enable further compromise depending on process privileges and deployment isolation.

General mitigation guidance

Mitigation generally focuses on preventing untrusted task metadata from reaching unrestricted deserialization logic.

Common defensive patterns include:

  • Applying a strict, centrally enforced allow-list for deserializable classes and modules on every code path.
  • Replacing general-purpose object deserialization with typed, schema-constrained data formats.
  • Treating DAG-authored task parameters and execution API values as untrusted input.
  • Separating scheduler privileges from worker and control-plane privileges.
  • Using process isolation, restrictive service accounts, and minimal filesystem and network permissions.
  • Ensuring security fixes cover all state-transition and background-sweep paths rather than only the primary execution path.

How teams detect issues like this

Organizations can look for:

  • Static-analysis findings involving unrestricted deserialization, dynamic imports, or reflective object construction.
  • Code review signals where scheduler or background-task code processes DAG-controlled values without schema and class restrictions.
  • Tests that exercise every task-state transition and periodic sweep with unexpected serialized values.
  • Runtime monitoring for unusual module imports, scheduler process termination, or unexpected child-process and network activity.
  • Policy checks requiring approved serialization formats and centrally defined deserialization allow-lists.

Automated security review tools may help identify unsafe parser and object-resolution patterns, but should be supplemented with state-machine and integration testing.

Sources

SourceLink
github.comgithub.com/apache/airflow/pull/70685
lists.apache.orglists.apache.org/thread/vygr0fh82cjzjp5k4vtfmboxryvm3lyn
cve.orgcve.org/CVERecord?id=CVE-2026-58076

Frequently asked

questions

Exploitability depends on whether an attacker can author a DAG or control human-in-the-loop task execution data through an exposed Airflow interface. It does not require a non-default configuration.

The important prerequisite is control over a DAG-authored value that reaches the task execution API and is later processed by the scheduler. The exact access requirements depend on Airflow authentication and authorization controls.

Restrict deserialization to explicitly approved types and modules, prefer schema-bound data formats, and ensure the restriction is applied consistently across scheduler background paths and state transitions.

Treat DAG and API-provided metadata as untrusted, use least-privilege scheduler deployments, test periodic and asynchronous code paths, and enforce organization-wide policies against unrestricted deserialization.

Find out what's already
exploitable in your codebase.