CVE-2026-68968: 
Homebrew Schwachstellenanalyse und -minderung

CVE-2026-68968 is an authorization bypass vulnerability in Apache Airflow's Backfill API caused by conflicting interpretations of the backfill_id path parameter between the authorization dependency and the route handler. An authenticated user with edit permission on any single DAG can read, pause, and cancel backfills belonging to any other DAG, including moving queued runs to failed status. All versions of Apache Airflow before 3.3.1 are affected; no non-default configuration is required to exploit the flaw. It was publicly disclosed on August 12, 2026, with a CVSS v3.1 base score of 7.5 (High) (Apache Advisory, Github Advisory).

The root cause is an interpretation conflict (CWE-436) between two components that parse the backfill_id path segment differently. The requires_access_backfill authorization dependency uses Python's built-in int(), which rejects values like "1.0" and "1.00", while the FastAPI route handler uses Pydantic's NonNegativeInt, which accepts and coerces those same values to integer 1. Because FastAPI resolves route dependencies before endpoint parameter validation, submitting a path value such as /backfills/42.0 causes the authorization dependency to fail parsing and fall back to a DAG ID supplied by the caller, while the handler successfully resolves backfill 42 — meaning the two components act on entirely different DAGs. Since backfill IDs are sequential integers, an attacker can trivially enumerate targets without any brute-force complexity (Github PR #70889, Openwall OSS-Sec).

An authenticated attacker with edit permission on as few as one DAG can read, pause, and cancel backfills belonging to any other DAG in the Airflow instance, and can move another DAG's queued runs to failed status, disrupting scheduled data pipelines. The confidentiality impact is high — backfill metadata and DAG operational state across the entire Airflow deployment are exposed — while integrity is partially affected through unauthorized state changes (pausing/cancelling runs). Availability of targeted DAG workflows can be disrupted by forcing queued runs to a failed state (Apache Advisory, Github Advisory).

No public proof-of-concept exploit code has been observed, and there is no evidence of in-the-wild exploitation at the time of disclosure (Apache Advisory). The vulnerability requires authentication but no elevated privileges beyond edit access to a single DAG, and the sequential nature of backfill IDs makes target enumeration trivial. The EPSS score is approximately 0.154% (5th percentile), indicating a currently low probability of exploitation within 30 days. The vulnerability is not listed in the CISA Known Exploited Vulnerabilities (KEV) catalog (Github Advisory).

1. Authenticate: Obtain valid credentials for an Apache Airflow instance running a version before 3.3.1, with at least edit permission on one DAG.
2. Identify a target DAG: Browse or query the Airflow API to identify DAGs to which you do not have authorized access.
3. Enumerate backfill IDs: Since backfill IDs are sequential integers, iterate through candidate IDs (e.g., 1, 2, 3…) to identify active backfills belonging to other DAGs.
4. Craft a malformed backfill_id: Construct an API request using a decimal-formatted backfill ID (e.g., /api/v1/backfills/42.0) that Pydantic's NonNegativeInt will coerce to 42, but which int() in the authorization dependency will reject, causing the dependency to fall back to a caller-supplied DAG ID.
5. Bypass authorization: Submit the crafted request (e.g., GET, PATCH, or DELETE to /api/v1/backfills/42.0) with a DAG ID in the request body or path that you do have edit access to; the authorization check passes against your permitted DAG while the handler acts on backfill 42 belonging to the target DAG.
6. Achieve objective: Read backfill details, pause, cancel, or move the target DAG's queued runs to failed status without holding any permission on that DAG (Github PR #70889, Openwall OSS-Sec).

• Network: API requests to Airflow backfill endpoints (e.g., /api/v1/backfills/<id>) where the backfill_id path segment contains a decimal value such as 42.0 or 42.00 rather than a plain integer.
• Logs: Airflow API access logs showing authenticated users accessing backfill endpoints for DAGs they do not own or have explicit permission on; repeated sequential backfill ID enumeration from a single user or IP address.
• Application Behavior: Unexpected backfill state changes (paused, cancelled, or failed) on DAGs whose owners did not initiate those actions; DAG run queues unexpectedly transitioning to failed status without corresponding scheduler or operator activity.

The primary remediation is to upgrade Apache Airflow to version 3.3.1 or later, which fixes the vulnerability by parsing backfill_id with the same TypeAdapter(NonNegativeInt) used by the route handlers, eliminating the divergence (Apache Advisory, Github PR #70889). As an interim measure, restrict API access to trusted networks and authenticated users with the minimum necessary DAG permissions, and monitor backfill API requests for anomalous patterns such as decimal-formatted IDs or cross-DAG access attempts. No non-default configuration workaround is available that fully mitigates the issue without upgrading.

The vulnerability was credited to Jarek Potiuk (Apache Airflow PMC member) as the remediation developer, and the fix was reviewed and merged by the Airflow core team prior to the security advisory publication (Openwall OSS-Sec, Github PR #70889). The NixOS security tracker also flagged the issue for the apache-airflow package in nixpkgs, indicating downstream ecosystem awareness. No significant broader media coverage or notable social media commentary beyond standard CVE tracking feeds has been observed.