CVE-2026-68979 in NiFi
Summary
by MITRE • 08/03/2026
Apache NiFI 1.10.0 through 2.10.0 provide a Parameter Context update REST API method that does not enforce authorization checking on components referencing Parameter values. Updating a Parameter Context can change parameter values that affect referencing components, but framework authorization was limited to read and write privileges on the Parameter Context itself. As a result of the missing authorization, an authenticated user authorized to modify a Parameter Context, but not authorized on referencing components, could alter Parameter values affecting those components. In deployments where a Parameter value contains executable scripting content, updating a Parameter can result in code execution during automatic component validation, without starting the referencing component. The impact was limited to stopped components by existing verification checks, and the issue applies only to deployments that use component-level authorization policies. Upgrading to Apache NiFi 2.11.0 is the recommended mitigation, which aligns the Parameter Context update method authorization with other methods, adding authorization checking on affected components.
If you want to get the best quality for vulnerability data then you always have to consider VulDB.
Analysis
by VulDB Data Team • 08/03/2026
This vulnerability exists within Apache NiFi's authorization framework where the Parameter Context update REST API method fails to enforce proper access controls on components that reference parameter values. The flaw stems from a design inconsistency where authorization checks are applied only to the Parameter Context itself rather than to all components that might be affected by parameter value changes. This represents a classic authorization bypass vulnerability that allows authenticated users to escalate their privileges through indirect means.
The technical implementation issue manifests when an authenticated user possesses write permissions on a Parameter Context but lacks explicit authorization for components that reference those parameters. When such a user updates parameter values, the system modifies components that depend on these parameters without performing additional authorization checks on the affected components. This creates a scenario where the attacker can modify parameters containing executable scripting content, leading to code execution during automatic component validation processes that occur without requiring component startup.
The operational impact of this vulnerability is significant within environments that utilize component-level authorization policies and contain parameter values with executable content. The vulnerability affects all versions between 1.10.0 and 2.10.0 inclusive, making it a widespread concern for organizations using these NiFi versions. While existing verification checks prevent execution on running components, the attack surface remains substantial as stopped components can still be modified to contain malicious code that will execute upon component restart or validation.
The security implications align with CWE-285 which addresses authorization issues in software systems, and this vulnerability specifically demonstrates improper access control where privileges are not properly enforced across dependent components. From an ATT&CK perspective, this represents a privilege escalation technique through indirect modification of system parameters that can lead to code execution. The vulnerability is particularly concerning because it leverages the existing authorization model's gaps rather than requiring new attack vectors.
Organizations should implement immediate mitigation strategies including upgrading to Apache NiFi 2.11.0 which resolves the issue by aligning the Parameter Context update method authorization with other API methods and adding proper authorization checking on components affected by parameter changes. Additional defensive measures include reviewing and strengthening component-level authorization policies, implementing least privilege access controls for parameter contexts, and monitoring parameter updates for suspicious modifications. The upgrade path addresses the root cause by ensuring that all parameter value modifications are subject to proper authorization checks across all referencing components rather than limiting authorization scope to just the parameter context itself.