CVE-2026-77180: NGINX Ingress Controller RCE Vulnerability

CVE-2026-77180 Overview

CVE-2026-77180 is a configuration injection vulnerability in the NGINX Ingress Controller. The flaw resides in the configuration generator, which writes multiple user-controllable annotation fields into the generated NGINX configuration without sanitization [CWE-76]. An authenticated attacker with permission to create or modify Ingress annotations through the Kubernetes API can inject arbitrary NGINX configuration directives. Successful exploitation may allow the attacker to create or delete files on the controller host or disable services. F5 notes that this issue is limited to the control plane and does not expose the data plane. Software versions that have reached End of Technical Support are not evaluated.

Critical Impact
An authenticated Kubernetes user with write access to Ingress annotations can inject NGINX directives, manipulate files, and disable services on the NGINX Ingress Controller.

Affected Products

F5 NGINX Ingress Controller (Kubernetes deployments configured with Ingress annotations)
Kubernetes clusters where users have RBAC permissions to create or modify Ingress objects
Refer to the F5 Security Article K000162601 for the current list of affected versions

Discovery Timeline

2026-09-02 - CVE-2026-77180 published to NVD
2026-09-02 - Last updated in NVD database

Technical Details for CVE-2026-77180

Vulnerability Analysis

The NGINX Ingress Controller translates Kubernetes Ingress objects into NGINX configuration blocks. Multiple annotation fields on Ingress resources are treated as trusted input and written directly into the generated configuration file. Because the generator does not sanitize or escape these values, an attacker can embed newline characters and additional NGINX directives inside an annotation value. When the controller reloads NGINX with the resulting configuration, the injected directives are parsed and applied. This turns a Kubernetes API write into arbitrary configuration control over the ingress process, enabling file creation, file deletion, or service disruption on the controller. The vulnerability is categorized under [CWE-76] (Improper Neutralization of Equivalent Special Elements).

Root Cause

The root cause is missing input neutralization in the configuration template rendering path. Annotation values flow from the Kubernetes API into the NGINX configuration generator without validation against a directive grammar or an allow-list of characters. Any authenticated principal with Ingress write permission becomes a trusted source of NGINX configuration.

Attack Vector

The attack requires authenticated access to the Kubernetes API with permission to create or update Ingress objects in a namespace served by the NGINX Ingress Controller. The attacker crafts an Ingress with a malicious annotation value that terminates the intended directive and appends attacker-chosen NGINX directives. On the next configuration reload, the injected directives execute inside the ingress process context. Impact is limited to the control plane of the ingress controller; the data plane serving application traffic is not directly exposed through this bug. Full technical detail is documented in the F5 Security Article K000162601.

Detection Methods for CVE-2026-77180

Indicators of Compromise

Ingress annotations containing newline characters, semicolons, or NGINX directive keywords such as load_module, include, access_log, or lua_
Unexpected NGINX configuration reloads correlated with Ingress create or update events in the Kubernetes audit log
New or modified files inside the ingress controller pod filesystem, particularly under /etc/nginx/ or writable mount paths
Service disruptions or worker process crashes in the NGINX Ingress Controller following an Ingress change

Detection Strategies

Enable Kubernetes API server audit logging for create, update, and patch verbs on ingresses.networking.k8s.io and alert on annotation values containing control characters
Diff rendered nginx.conf between reloads and flag directives introduced by annotation-driven templates that fall outside the expected schema
Correlate ingress controller pod telemetry (process launches, file writes, network egress) with the Kubernetes user identity that triggered the reload

Monitoring Recommendations

Monitor RBAC bindings that grant create or update on Ingress resources and review them against least-privilege expectations
Alert on unexpected child processes, file system modifications, or outbound connections from ingress controller pods
Track ingress controller reload frequency and failure rate as leading indicators of injection attempts

How to Mitigate CVE-2026-77180

Immediate Actions Required

Apply the fixed NGINX Ingress Controller release identified in the F5 Security Article K000162601
Audit RBAC and remove create, update, or patch permissions on Ingress resources from users and service accounts that do not require them
Review existing Ingress objects for annotation values containing newlines, semicolons, or unexpected NGINX directives and remediate any suspicious entries
Rotate any secrets or credentials that were reachable from the ingress controller pod if injection is suspected

Patch Information

F5 has published remediation guidance and fixed versions in the F5 Security Article K000162601. Upgrade the NGINX Ingress Controller to a supported release listed in that advisory. Versions past End of Technical Support are not evaluated and should be replaced rather than patched.

Workarounds

Enable --allow-snippet-annotations=false and equivalent controller flags that disable annotation-driven snippet directives where supported
Use an admission controller (such as OPA Gatekeeper or Kyverno) to reject Ingress objects whose annotation values contain newline characters or NGINX directive tokens
Restrict namespaces served by the ingress controller and enforce namespace-scoped RBAC to limit which principals can influence generated configuration

bash

# Example Kyverno policy fragment to block newline injection in Ingress annotations
# Apply with: kubectl apply -f block-annotation-injection.yaml
apiVersion: kyverno.io/v1
kind: ClusterPolicy
metadata:
  name: block-ingress-annotation-injection
spec:
  validationFailureAction: Enforce
  rules:
    - name: reject-newline-in-annotations
      match:
        any:
          - resources:
              kinds:
                - Ingress
      validate:
        message: "Ingress annotations must not contain newline characters."
        pattern:
          metadata:
            =(annotations):
              =(*): "!*\n*"