CVE-2026-48828: Apache Airflow Bulk Variables API Redaction Bypass – Secret Exposure in JSON Variables
Apache Airflow's Bulk Variables API has a flaw where it bypasses the built-in redaction mechanism when retrieving JSON-formatted variables. Normally, Airflow hides the values of variables with secret-related key names (like `db_password`, `api_token`, or `service_secret`). However, this protection fails for JSON variables accessed through the bulk API because the redactor isn't given the variable's key name to evaluate. An authenticated user with read permissions to bulk variables can therefore extract sensitive data that should have been hidden, even though the variable name itself would normally trigger redaction. The exposure is limited to JSON-typed variables and requires existing access to Airflow's UI or API.
Source data · NVD / CISA · public domain
- CVSS
- 3.1 · 6.5 MEDIUM · CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:N/A:N
- Weaknesses (CWE)
- CWE-200
- Affected products
- 1 configuration(s)
- Published / Modified
- 2026-07-07 / 2026-07-08
NVD description (verbatim)
The Bulk Variables API in Apache Airflow called the redactor without passing the variable's key, so the key-based `should_hide_value_for_key` check (which triggers on secret-suffixed key names like `*_password` / `*_token` / `*_secret`) could not fire for JSON-decodable variable values. An authenticated UI/API user with bulk Variable read permission could retrieve plaintext values from JSON variables whose key would otherwise trigger redaction. Affects deployments that store sensitive values in JSON-typed Airflow Variables under secret-suffixed key names. Users are advised to upgrade to `apache-airflow` 3.3.0 or later (the fix landed on `main` after 3.2.2; no 3.2.x backport).
3 reference(s) · View on NVD →
SEC.co analysis · AI-assisted, reviewed against source
Technical summary
The Bulk Variables API in Apache Airflow calls its value-redaction function without providing the variable key as context. Airflow's redaction logic includes a key-based check (`should_hide_value_for_key`) that identifies secret-related variable names via suffix matching (e.g., `*_password`, `*_token`, `*_secret`). Because the bulk API omits the key during redaction, this check cannot execute, and JSON-decodable variable values pass through unredacted. An authenticated user with bulk Variable read permission can then retrieve plaintext sensitive values from variables whose keys would ordinarily trigger redaction. The vulnerability is specific to JSON variables; non-JSON variables and single-variable retrieval pathways appear unaffected. The fix involves passing the variable key to the redactor so the key-based check can function as designed.
Business impact
Organizations running Apache Airflow may face exposure of secrets stored as JSON variables in Airflow's Variable store. This could compromise database credentials, API tokens, service authentication material, or other sensitive configuration stored under secret-suffixed key names. The impact is limited to users with authenticated bulk Variable read access (typically platform operators, DAG developers, or administrative staff), but the exposure of plaintext secrets could enable lateral movement, unauthorized service access, or data exfiltration. Deployments that rely on Airflow's secret-naming conventions for compliance or defense-in-depth are particularly at risk.
Affected systems
Apache Airflow versions up to and including 3.2.2 are vulnerable. The fix is included in Apache Airflow 3.3.0 and later versions. Versions prior to 3.2.0 have not been identified as receiving a backport; upgrading to 3.3.0 or later is the primary remediation path. Affected deployments are those storing sensitive values in JSON-typed Airflow Variables under secret-suffixed key names and granting authenticated users bulk Variable read permissions.
Exploitability
Exploitation requires authentication—an attacker must have an active account or credential for Airflow with the 'bulk Variable read' permission. The attack surface is the Airflow UI or REST API bulk variable endpoint. Once authenticated, the exploit is trivial: a user simply queries bulk variables and inspects JSON values that would otherwise be redacted. No complex steps, special network positioning, or privilege escalation are necessary. However, the attacker's actions may be logged, and the theft is confined to users with existing read access; external, unauthenticated exploitation is not possible.
Remediation
Upgrade to Apache Airflow 3.3.0 or later. There is no published patch for the 3.2.x branch; users on 3.2.2 or earlier must move to 3.3.0. Verify with your Apache Airflow release notes and vendor advisory that your version includes the fix. As an interim measure, review and restrict bulk Variable read permissions to only those users who require it, and audit recent Variable access logs for any suspicious bulk queries. Consider migrating highly sensitive secrets from JSON variables to dedicated secret-management systems or Airflow's SecretBackend integrations to reduce reliance on Airflow's built-in redaction alone.
Patch guidance
Upgrade to apache-airflow version 3.3.0 or later. The fix was merged to the main branch after 3.2.2 release and is not available as a backport for the 3.2.x series. Verify the applied version by checking your Airflow instance version string (visible in the WebUI footer or via `airflow version` CLI). Test the upgrade in a non-production environment first to confirm compatibility with your DAGs and custom plugins. After upgrading, spot-check bulk Variable API responses to confirm that secret-suffixed JSON variables are properly redacted.
Detection guidance
Review Airflow audit logs and API access logs for bulk Variable queries issued by authenticated users. Look for repeated or bulk requests to the `/api/v1/variables` endpoint (or equivalent UI bulk fetch operations) within a short timeframe. Examine which users hold the 'bulk Variable read' permission and whether their access patterns are consistent with their stated roles. If you suspect exposure, audit the contents of JSON-typed variables with secret-related key names (e.g., `db_password`, `api_token`) in your Airflow Variable store. Rotate any secrets that were stored in such variables during the window before you can patch or restrict access.
Why prioritize this
Although the CVSS score of 6.5 is in the MEDIUM range, organizations storing secrets in Airflow Variables should prioritize this patch. The vulnerability is easy to exploit by anyone with a legitimate account, requires no external network access, and directly exposes plaintext credentials. Airflow is often deployed in data-centric environments where DAG developers and operators have broad access; the presence of such users with read permissions increases risk. The fact that no 3.2.x patch is offered means there is a forced upgrade path, which may justify near-term scheduling. Organizations not storing secrets in JSON Airflow Variables, or those using dedicated secret-management backends, face lower immediate risk but should still plan an upgrade within a standard patch cycle.
Risk score, explained
The CVSS 3.1 score of 6.5 reflects a network-accessible API (AV:N) with low attack complexity (AC:L), requiring authentication (PR:L), no user interaction (UI:N), a single security domain (S:U), and high confidentiality impact (C:H) with no integrity or availability impact. The score appropriately captures that an authenticated, low-privileged user can gain high-confidence access to plaintext secrets. The score does not reflect the operational severity in Airflow-heavy environments where this data might unlock further attacks; organizations should apply their own risk context regarding the sensitivity of secrets and the trustworthiness of bulk Variable readers.
Frequently asked questions
Do I need to rotate all my Airflow Variables after patching?
Only if you suspect your Variables were accessed or exfiltrated before the patch. Review your Airflow audit logs to check for suspicious bulk Variable queries. If no unauthorized access is evident and your deployment has not been public-facing or compromised, rotation may not be necessary. However, as a precaution, consider rotating any truly critical secrets (database passwords, API keys used for sensitive operations) if they were stored as JSON variables with secret-suffixed names.
Are non-JSON variables affected, or only JSON-typed variables?
Only JSON-typed Airflow Variables are affected by this vulnerability. Airflow Variables of other types (string, dict serialized as non-JSON, etc.) are not impacted because they do not pass through the same JSON-decoding and bulk-redaction code path. If your secrets are stored as plain string or non-JSON variable types, this vulnerability does not expose them, though best practice is to use a dedicated secret backend.
What if I cannot upgrade to 3.3.0 immediately?
As an interim mitigation, restrict the 'bulk Variable read' permission to a minimal set of trusted users or roles. Audit which accounts currently hold this permission and remove it from users who do not require it. Monitor audit logs for unexpected bulk Variable queries. However, this does not close the vulnerability—upgrades should be scheduled as soon as feasible, since the intermediate mitigations are controls, not fixes.
Should I use Airflow Variables for secrets at all, or should I use a secret backend?
Airflow's built-in Variable store is not designed as a primary secrets management system. For production deployments, use Airflow's SecretBackend integration with dedicated solutions such as HashiCorp Vault, AWS Secrets Manager, or Kubernetes Secrets. These systems offer stronger access controls, encryption, rotation policies, and audit trails. Airflow Variables are best reserved for non-sensitive configuration and settings.
This analysis is provided for informational and educational purposes by SEC.co and is not a substitute for vendor guidance or professional security assessment. CVSS scores and CWE classifications are derived from official CVE records and NVD data. Patch version information is based on the Apache Airflow advisory and should be verified against your deployment and vendor release notes before proceeding. Security posture and risk tolerance vary by organization; apply this information within your own operational and governance context. SEC.co makes no warranty regarding the completeness or accuracy of this information and disclaims liability for decisions made in reliance on it. Source: NVD (public-domain), retrieved 2026-08-16. Analysis generated by SEC.co (claude-haiku-4-5).
Related vulnerabilities
- CVE-2026-34905MEDIUMApache Answer Unlisted Question Information Disclosure Vulnerability
- CVE-2026-42358MEDIUMApache Airflow Secret Masking Bypass for Deeply Nested JSON Variables
- CVE-2026-42360MEDIUMApache Airflow Nested Template Secret Masking Bypass
- CVE-2026-45192MEDIUMApache Airflow Connection API Credential Leak – CVSS 6.5
- CVE-2026-47340MEDIUMApache DolphinScheduler Unauthorized Alert Instance Access
- CVE-2026-48891MEDIUMApache Airflow DAG Enumeration via Dependency Graph Information Disclosure
- CVE-2026-48892MEDIUMApache Airflow Config API Secrets Exposure (MEDIUM)
- CVE-2026-49487MEDIUMApache Airflow REST API Exposes Deferred Task Secrets