Apache Airflow CVE-2025-54550

We need to produce a JSON object per the instructions. Let's analyze each field.

First, product_name: "1-3 words ONLY. The specific product or service name affected." CVE affects Apache Airflow example documentation. However, the vulnerability is in the documentation example that users might have copied. The product is Apache Airflow, specific component: documentation/examples. But the description says "It does not affect Airflow release". The vulnerable pattern is in the documentation, and users who followed it may have vulnerable code. So the primary product is Apache Airflow? The CPE: apache:airflow.* So product_name: "Apache Airflow" fits. Possibly "Apache Airflow documentation" but not typical. Product name should be the software. It says "1-3 words ONLY", so "Apache Airflow" is two words. That is good.

summary: "2-3 sentence plain-language summary for security professionals. CRITICAL: Do NOT copy or paraphrase Description — write an original synthesis... Start with the specific impact verb and product, e.g. 'Remote code execution in Apache Tomcat 9.x allows...'. Explain WHAT the vulnerability is, WHO is affected (specific product/version), and WHAT an attacker can do. Mention if actively exploited (KEV), if POC exists, and EPSS risk if notable."

From the description: The example_xcom example in Airflow documentation implemented an unsafe pattern of reading XCom values, which could allow a UI user who can modify XComs to execute arbitrary code on the worker. It's a code injection via unsafe pattern, but only if the user replicated the pattern. The vulnerability is not in the product itself but in the example. The CVSS is 8.1, which seems high for something that requires the user to copy a bad pattern. But it's rated Low severity. EPSS is 0.03%, very low. No KEV mentioned. Patch: documentation updated in Airflow 3.2.0. So we need to synthesize: "Code injection in Apache Airflow's example_xcom documentation that, if followed by users, allows UI users with XCom modification privileges to execute arbitrary code on the worker. Affects users who implemented the documented unsafe pattern; Airflow 3.2.0 documentation provides a safer alternative." Mention EPSS 0.03%, no known active exploitation, no public POC? Actually, there is no mention of POC apart from the CVE itself being published, but the description suggests it's just a pattern. Not a POC exploit. So "no public exploit identified". We'll say "not actively exploited" and "EPSS score 0.03% suggesting minimal exploitation likelihood". So summary: "Code injection in Apache Airflow's example_xcom documentation allows UI users who can modify XComs to execute arbitrary code on the worker. This risk exists only for deployments that replicated the unsafe pattern from the documentation. Airflow 3.2.0 updated documentation to recommend a safe pattern, and EPSS data indicates a very low exploitation probability (0.03%)."

That's 2-3 sentences. No copy.

technical_context: Explain underlying technology/library/protocol. CWE-94: Code Injection. XCom (cross-communication) in Apache Airflow is a mechanism for tasks to exchange data. The example showed directly templating XCom values into a bash command string without proper escaping or validation, enabling command injection. The CPE confirms affected product Apache Airflow all versions before 3.2.0 (since the documentation existed before that version). The root cause: improper neutralization of special elements in a command (CWE-94). So we can explain that.

risk_assessment: "Assess real-world risk using ALL available signals: CVSS vector (attack vector, complexity, privileges), EPSS exploitation probability, KEV status, POC availability, SSVC decision framework (exploitation status, automatable, technical impact). Compare and contrast these signals. Is this a real priority or just a high-CVSS-but-low-real-risk issue? If any key data is missing or conflicting, STATE IT EXPLICITLY." CVSS 8.1: AV:N/AC:L/PR:L/UI:N/S:U/C:H/I:H/A:N. That's high, but EPSS 0.03% is very low. SSVC: Exploitation: none, Automatable: no, Technical Impact: total. So exploitation is not active, not automatable, but total impact if exploited. That suggests high impact but low likelihood because it requires a user to have copied a specific pattern from documentation. The vulnerability is not in the core product but in user implementations. So it's a documentation issue, not a product vulnerability. Many users might not have enabled example dags or copied that pattern. So high CVSS but low real risk. Conflicting: CVSS indicates network attack vector, low privileges, no user interaction, but in practice, the attacker must be an UI user with XCom modification rights, which is authenticated. That matches PR:L. AV:N is plausible if the Airflow UI is network accessible. AC:L because the pattern is easy to exploit if the vulnerable code exists. So it's a high-severity issue if the user has the vulnerable code, but the footprint is likely tiny. So prioritize low. We'll state that.

affected_products: Write a concise paragraph listing affected products with versions. "Apache Airflow documentation versions prior to 3.2.0 contain the unsafe pattern in example_xcom.py. Users who implemented the example pattern in their DAG code are affected regardless of Airflow version. Airflow 3.2.0 documentation includes the corrected safe pattern. CPE: cpe:2.3:a:apache_software_foundation:apache_airflow:*:*:*:*:*:*:*:*. EUVD lists affected versions: Apache Airflow 0 <3.2.0." Note: the patch is a documentation update, not a code fix. So affected products are Airflow documentation versions before 3.2.0, and downstream users' custom code. So we can state that.

remediation: "Write a concise paragraph with actionable remediation steps. Start with the primary fix (patch/upgrade with exact version), then mention workarounds if relevant. Include advisory URLs... If no patch is available, suggest SPECIFIC compensating controls." The advisory says: Documentation of Airflow 3.2.0 contains improved version. So users should review their code and adopt the safe pattern shown in the updated example (using environment variables instead of direct templating). No code patch needed because the vulnerability is in user code. So remediation: "Review any custom DAG code that uses XCom value to construct bash commands, and refactor to use the safe pattern from Airflow 3.2.0 documentation: pass XCom values as environment variables and reference them via $VAR in the command." We can refer to the PR and advisory. Also, as a general measure, restrict XCom modification permissions to trusted UI users. But that's already indicated: UI users already highly trusted. So no need. So the primary remediation is to change user code. The advisory URL: https://lists.apache.org/thread/3mf4cfx070ofsnf9qy0s2v5gqb5sc2g1

exploit_scenario: "Brief realistic attack scenario in 2-3 sentences. If POC exists, note that. Factor in attack vector and complexity from CVSS." An attacker with Airflow UI access (low privilege, XCom modification rights) could replace an XCom value with a malicious command payload. When a DAG task uses the unsafe pattern to read that XCom and execute it in bash, the malicious command runs on the worker node. This could lead to data exfiltration or further compromise. No public POC, but the pattern is straightforward.

exploitation_conditions: CRITICAL FIELD. Need specific, concrete prerequisites. From description: "UI user who had access to modify XComs" and "users following the example could replicate the bad pattern". So conditions: 1) The Airflow deployment must contain a DAG that directly templates XCom values into a bash command (the unsafe pattern). 2) The attacker must have UI access with permission to modify XCom values (i.e., at least read/write on the target XCom). 3) The DAG must be triggered, and the task that reads the XCom and executes the command must run after the XCom value is poisoned. So the exploitation conditions: "The target environment must contain a DAG task that unsafely constructs a bash command using XCom values (as shown in the affected example). An attacker must be an authenticated Airflow UI user with privileges to modify the XComs used by that DAG. The attacker then triggers the DAG, causing the injected command to execute on the worker." Also note: No special configuration per se, but the presence of the vulnerable pattern is required. I'll phrase it carefully.

attack_chain: "3-7 short steps separated by ' → ' (arrow). Must be grounded in actual CVE data." Kill chain phases. Potential steps: Authenticate as UI user with XCom write permissions → Poison target XCom with malicious shell command → Trigger DAG run that reads the poisoned XCom → DAG task templates XCom into bash command without sanitization → Bash executes the payload → Achieve code execution on worker node. So chain: "Authenticate to Airflow UI as user with XCom write access → Locate target DAG that uses unsafe XCom pattern → Inject malicious command into XCom variable → Trigger DAG run that reads the XCom → BashOperator executes crafted command → Gain arbitrary code execution on worker". That's 6 steps. Use arrow.

confidence_notes: "1-3 sentences about data completeness and confidence. State what is CONFIRMED, what is INFERRED, what is UNKNOWN." Confirmed: The unsafe pattern existed in example documentation before 3.2.0 (confirmed by GitHub diff). The vulnerability description confirmed by Apache advisory. The patch is documentation update, not code change. CVSS vector provided by NVD. EPSS low. No active exploitation. Unknown: exact number of users who copied the pattern, but likely low. So confidence: "Vulnerability confirmed by Apache advisory and GitHub PR. The CVSS vector is from NVD. No active exploitation detected, EPSS extremely low. The number of affected deployments replicating the example is unknown but likely minimal."

prevalence: ONE word only: low? Airflow is widely used enterprise scheduler, but the vulnerability is not in the default installation; it's only if someone copied that specific pattern. So the product itself (Apache Airflow) is high prevalence, but the vulnerable code pattern is not ubiquitous. The prevalence field is about "REAL-WORLD deployment footprint of the affected product". The affected product as defined in product_name is Apache Airflow. But the vulnerability is in the documentation example, not the product itself. However, the question asks: "Estimate the REAL-WORLD deployment footprint of the affected product — how widely it is actually deployed in production." So Airflow is widely deployed. But the CVE description says "It does not affect Airflow release - example_dags are not supposed to be enabled in production environment, however users following the example could replicate the bad pattern." So the affected product is actually the documentation and the users' custom code. The product is Apache Airflow, but the vulnerability is not in the released software. So the deployment footprint of Apache Airflow is high, but the vulnerable scenario is rare because it requires manual copying of an example. So the prevalence of the actual vulnerable condition is low. But the field asks for "prevalence" of the affected product. It says "ubiquitous | high | medium | low | rare | unknown". The product is Apache Airflow. That could be "high" because Airflow is widely used in data engineering. But then the vulnerability itself is low prevalence. However, I think it's meant to be the product, not the vulnerability. The guidelines: "Estimate the REAL-WORLD deployment footprint of the affected product — how widely it is actually deployed in production. This is INDEPENDENT of severity (a CRITICAL flaw in a rare product is still rare)." So if the product is Apache Airflow, it's high. But then the vulnerability is just a documentation issue, and it's not in the product itself, but the CVE is tied to the product. I'll decide: product is Apache Airflow, so prevalence should be high because many enterprises use it. But the description says "It does not affect Airflow release", so maybe they don't consider the product as vulnerable. Yet the CPE lists Apache Airflow as affected. The affected product string often includes the software that has the flaw, even if it's just documentation. So I'll set prevalence to high, because Apache Airflow is a widely-deployed enterprise scheduler. Prevalence basis: "widely-deployed enterprise workflow scheduler". However, given that the actual flaw is in user code and not default, maybe the prevalence of the vulnerable code pattern is low, but the product prevalence is high. The instruction says: "the affected product — how widely it is actually deployed in production." The affected product is Apache Airflow, so high. I'll go with high.

prevalence_basis: "core data pipeline tool,