This CVE reveals a parsing divergence between FastAPI's dependency injection layer and endpoint validation that constitutes a class-of-vulnerability, not merely a one-off implementation error. The auth dependency used int() to parse the backfill_id path parameter, while the endpoint model used pydantic's NonNegativeInt. When int('1.0') raises a ValueError, FastAPI's dependency resolution silently falls back to treating the parameter as the dag_id instead—allowing an attacker with edit access to one Dag to manipulate backfills on any other Dag by simply providing a malformed backfill_id that triggers this fallback behavior.
The sequential backfill ID generation compounds the severity: enumeration isn't required, only incrementation. Any authenticated user with edit permissions to a single Dag can traverse the entire backfill history of every pipeline in the system. This transforms a local authorization bypass into systemic pipeline-state manipulation.
The CVSS 7.5 score undersells the operational impact. Moving queued production runs to failed state in another user's pipeline creates downstream integrity violations that extend beyond the API boundary—false provenance in compliance reports, triggered SLA violations, and corrupted audit trails may persist long after the technical vulnerability is patched. In OT-adjacent contexts where pipelines govern physical processes, this integrity violation carries risk profiles that CVSS's authorization-bypass vector doesn't model.
The structural pattern is reproducible: any FastAPI codebase with auth dependencies that transform path parameters before validation operates on the same silent assumption. When dependency resolution fails parsing in a security-relevant layer, it doesn't log the failure or halt the chain—it returns control to the caller with different data than the endpoint will eventually validate. Audit checklists should explicitly test whether auth-layer and endpoint-layer parsing of the same input stay synchronized. The fix is trivial (unify to NonNegativeInt), but the discovery window between code commit and CVE publication measured in years—the parsing divergence sat invisibly in production because nothing in FastAPI's request lifecycle signals that two parsers operating on the same segment are security-relevant and must agree.