Summary
An authorization flaw in Apache Airflow allows UI/API users with asset materialize permission to trigger DAGs they are not explicitly authorized to access.
Under certain configurations, this can let a lower-privileged user initiate execution of workflows belonging to other teams or environments, potentially impacting data, infrastructure, or downstream systems.
Affected context
This issue occurs in Apache Airflow environments where:
- Fine-grained permissions are used to control access to DAGs and assets
- Users are granted asset materialize permissions, but should not have access to all DAGs
- DAG execution can be indirectly triggered via asset-related operations (e.g., materialization)
In such setups, the permission model can inadvertently allow users to trigger DAGs outside of their intended scope.
Exploit preconditions
- Attack surface: Airflow web UI and Airflow REST API endpoints related to assets/materialization and DAG triggering.
- Required access: Valid Airflow user account with asset materialize permission, but without direct access to some target DAGs.
- Trigger point: Initiating an asset materialization or related operation that results in triggering a DAG.
- Why exploitation is possible: The authorization layer does not consistently enforce DAG-level access checks when DAG execution is initiated via asset materialization, allowing users with specific asset permissions to indirectly trigger unauthorized DAGs.
Why this happens
The root cause is an incorrect authorization check (CWE-863) in the logic that connects asset materialization to DAG execution.
Instead of verifying that the calling user has explicit permission to access and trigger a given DAG, the system relies on broader or indirect permissions (such as asset materialize) to authorize the operation.
This creates a gap between the intended security policy (per-DAG access control) and the implemented checks, enabling privilege escalation through alternative execution paths.
Potential impact
- Unauthorized triggering of DAGs owned by other teams or projects
- Execution of workflows that access sensitive data or infrastructure
- Unintended modification of datasets or data products through unauthorized runs
- Disruption of scheduled or controlled deployment pipelines
- Increased blast radius if DAGs perform administrative or high-privilege operations
General mitigation guidance
Effective mitigation focuses on tightening authorization boundaries and ensuring consistent permission checks:
- Enforce per-DAG authorization checks for all execution paths, including asset-based or indirect triggers.
- Apply the principle of least privilege when assigning asset materialize permissions; avoid broad grants to generic roles.
- Isolate high-risk DAGs (those with sensitive data or infrastructure access) behind more restrictive roles and approval workflows.
- Design access control such that asset-level permissions do not implicitly grant DAG-level execution unless explicitly intended.
- Regularly review permission mappings and role definitions to ensure they reflect the actual security policy.
How teams detect issues like this
Detection typically combines access review, logging, and policy enforcement:
- Enable detailed audit logging of DAG trigger events, including the initiating user, source endpoint (UI/API), and associated assets.
- Periodically review logs for patterns where users without explicit DAG access are causing those DAGs to run.
- Use static or configuration analysis to identify code paths and configuration options where asset operations can trigger DAGs without explicit DAG permission checks.
- Incorporate automated policy checks in CI/CD that flag new features or endpoints triggering DAGs without clearly defined authorization gates.
- During security reviews, verify that every DAG execution entry point (UI buttons, API endpoints, asset hooks) enforces the same permission model.

