/

CVE-2026-30911

Severity:

HIGH RISK

(8.1)

Missing Authorization in Apache Airflow Execution API HITL

CVE-2026-30911

Analyzed

Vulnerability type

Category:

Missing Authorization

CWE:

CWE-862

Impact:

Privilege Escalation and Cross-Tenant Workflow Manipulation

Severity:

HIGH RISK

(8.1)

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 Execution API Human-in-the-Loop (HITL) endpoints in versions 3.1.0 through 3.1.7 lack proper authorization checks, allowing any authenticated task instance to act on HITL workflows it does not own.

Under these conditions, an attacker who controls any authenticated task instance can read, approve, or reject HITL workflows for other task instances, overriding intended manual controls and workflow boundaries.

Affected context

This vulnerability affects Apache Airflow deployments using the Execution API's Human-in-the-Loop (HITL) functionality in versions 3.1.0 through 3.1.7.

It manifests where:

  • HITL endpoints are exposed to task instances via the Execution API
  • Any authenticated task instance can reach these endpoints
  • Authorization is assumed to be enforced but is not properly checked per workflow/task instance

It is particularly relevant in environments where different teams, tenants, or workflows should be isolated from each other's HITL decisions.

Exploit preconditions

  • Attack surface: Airflow Execution API HITL endpoints (server-side API).
  • Required access: Ability to operate or impersonate any authenticated task instance that can call HITL endpoints.
  • Trigger point: Invoking HITL API operations (e.g., read, approve, reject) while specifying HITL workflows belonging to other task instances.
  • Why exploitation is possible: The API performs authentication but does not enforce fine-grained authorization that ties HITL actions to the owning task instance or workflow, allowing arbitrary cross-instance access.

Why this happens

The issue stems from missing authorization checks on sensitive Execution API HITL operations.

While requests are authenticated, the system fails to verify that the caller is authorized to interact with the specific HITL workflow it targets.

This maps to CWE-862: Missing Authorization, where access control decisions for particular resources or actions are not implemented, leading to unintended access and privilege escalation.

Potential impact

  • An authenticated task instance can read HITL workflows belonging to other task instances.
  • HITL approvals can be granted for workflows owned by other teams or tenants, bypassing intended human review.
  • HITL rejections can be sent for unrelated workflows, causing disruption or denial of service to legitimate processes.
  • Compliance and audit guarantees around manual approval steps can be undermined.
  • Business logic and production workflows can be manipulated by less-privileged tasks.

General mitigation guidance

Mitigations focus on enforcing strict, resource-level authorization and minimizing blind trust in authenticated identities:

  • Introduce fine-grained authorization checks that bind HITL actions to the owning task instance, DAG, or tenant, and verify that the caller has explicit rights for that resource.
  • Adopt a principle-of-least-privilege model for task instances, granting only the minimum HITL capabilities required for each workflow.
  • Centralize access control logic for APIs so that all Execution API endpoints consistently perform both authentication and authorization before acting.
  • Use clear resource scoping (e.g., DAG ID, run ID, task ID, tenant ID) in access control decisions rather than relying on generic "authenticated" status.
  • Reduce implicit trust in internal components: treat calls from task instances as untrusted until they pass explicit authorization checks.

How teams detect issues like this

Detection typically involves reviewing both configuration and code paths that handle HITL operations:

  • Static analysis and code review:
  • Search for Execution API HITL endpoints that perform sensitive actions (approve/reject/read workflows) without checking ownership or role-based permissions.
  • Verify that authorization middleware or decorators are consistently applied to HITL routes and not just to other Execution API endpoints.
  • Look for patterns where authentication is checked (e.g., verifying a token) but no subsequent resource-level permission check is made.
  • Operational monitoring:
  • Log all HITL actions with caller identity, task instance, workflow identifiers, and decision type (approve/reject).
  • Analyze logs for anomalous patterns where a single task instance interacts with many unrelated workflows or cross-tenant resources.
  • Security policy enforcement:
  • Use API gateways or service meshes that can enforce access control or route-level policies based on identity and resource attributes.
  • Integrate automated security testing into CI/CD to simulate cross-instance HITL access and verify that it is denied.

Sources

SourceLink
github.comgithub.com/apache/airflow/pull/62886
lists.apache.orglists.apache.org/thread/1rs2v7fcko2otl6n9ytthcj87cmsgx51
openwall.comopenwall.com/lists/oss-security/2026/03/17/2

Frequently asked

questions

It can be exploited remotely if an attacker can trigger or control an authenticated task instance that has network access to the Execution API HITL endpoints. The vulnerability itself is not limited to local attacks; it depends on how task instances are invoked and what connectivity they have.

The attacker needs the ability to operate or impersonate any authenticated task instance that can call the HITL endpoints. They do not need to own the target workflow; the lack of authorization checks allows them to act on other instances' HITL workflows.

Implement robust, resource-level authorization for all sensitive API operations. Each HITL action should verify that the caller is allowed to interact with the specific workflow or task instance, using roles, ownership checks, or tenancy boundaries, rather than relying solely on being "authenticated."

Design APIs with access control as a first-class concern: centralize authorization logic, use consistent middleware/decorators, define clear resource ownership models, and require explicit checks for every sensitive operation. Complement this with security-focused code reviews, automated tests for access control, and logging that makes unauthorized access attempts visible.

Find out what's already
exploitable in your codebase.