Description

When NGINX Ingress Controller is configured with Ingress annotations, an injection vulnerability exists in the configuration generator of NGINX Ingress Controller. Multiple user-controllable fields are written into the generated NGINX configuration without sanitization. An authenticated attacker with permission to create or modify these annotations may craft values that inject arbitrary NGINX configuration directives. Impact: An authenticated attacker granted write access to NGINX Ingress Controller Ingress annotations through the Kubernetes API may be able to inject arbitrary NGINX configuration directives, create or delete files, or disable services. There is no data plane exposure; this is a control plane issue only. Note: Software versions which have reached End of Technical Support (EoTS) are not evaluated.

Executive Summary

Technical Details

Mitigations

References

Additional Metadata

{
  "score": "8.3",
  "pubDate": "2026-09-02T16:17:23.407Z",
  "pubdate": "2026-09-02T16:17:23.407Z",
  "executiveSummary": "The NGINX Ingress Controller is affected by an injection vulnerability residing in the configuration generator component. This flaw occurs because multiple user-controllable Ingress annotations are incorporated into the generated NGINX configuration files without undergoing rigorous sanitization or validation processes.\nThe vulnerability allows an authenticated attacker possessing write access to Ingress resources within the Kubernetes API to inject arbitrary NGINX configuration directives. By manipulating these annotations, an attacker can influence the behavior of the Ingress Controller at the control plane level.\nThe impact is significant, potentially enabling unauthorized file system operations, such as file creation or deletion, and the disruption of services managed by the controller. It is critical to note that this is exclusively a control plane vulnerability; there is no direct exposure of the data plane. The primary risk implication is a breach of the integrity and availability of the NGINX configuration state. Exploitation is contingent upon the attacker already having the necessary Kubernetes permissions to modify Ingress resources, making this an internal threat vector that necessitates strict Role-Based Access Control (RBAC) oversight.",
  "technicalDetails": "The root cause of this vulnerability lies in the improper handling of user-supplied data during the NGINX configuration template rendering process. The NGINX Ingress Controller utilizes a templating engine to translate Kubernetes Ingress annotations into functional NGINX configuration directives. When the controller processes an Ingress resource, it reads values defined in various annotations and concatenates these strings into the final configuration file without enforcing character escaping or syntax validation.\nAn authenticated attacker with the capability to create or modify Ingress objects via the Kubernetes API can inject malicious NGINX configuration syntax by inserting newline characters (e.g., \\n) or specific directive delimiters within an annotation value. This technique effectively breaks out of the intended directive context, allowing the attacker to terminate the current block and append arbitrary configuration parameters. Because the NGINX configuration is reloaded by the controller process upon updates, the injected directives are interpreted by the NGINX master process.\nThe attack flow follows a structured sequence: First, the attacker authenticates to the Kubernetes API server and identifies an Ingress resource where they hold write permissions. Second, the attacker crafts a malicious payload—such as an directive that specifies an alternative log location, triggers a file system operation via modules like lua_package_path or similar configuration hooks, or disrupts upstream server definitions. Third, the attacker updates the targeted Ingress annotation with this payload. Fourth, the Ingress Controller detects the resource change, regenerates the configuration including the malicious directives, and initiates an NGINX reload. Finally, the NGINX process executes the injected directives, leading to the desired unauthorized configuration state.\nThe vulnerability is restricted to the control plane, as it targets the logic responsible for configuration generation rather than the traffic-handling data plane directly. However, the resulting configuration changes can have severe consequences for the data plane, potentially exposing internal services or facilitating unauthorized access by misconfiguring rewrite rules or security policies. The vulnerability assumes that the attacker already has legitimate (though potentially unauthorized or over-privileged) access to the Kubernetes control plane, emphasizing the danger of overly permissive RBAC policies regarding Ingress object modifications."
}