Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessObtain Kubernetes credential with Ingress write RBAC permission
-
DeliveryCraft Ingress annotation value containing NGINX directive syntax
-
ExploitSubmit malicious Ingress resource via Kubernetes API
-
ExecutionIngress Controller regenerates nginx.conf with injected directives
-
PersistNGINX loads attacker-influenced configuration
-
ImpactCreate/delete files or disable ingress services
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A05:2025 - Injection
ASVS 5.0
V1 - Encoding and Sanitization Special element neutralization
|
| Exploitation Conditions | Exploitation requires an authenticated Kubernetes principal - user account, service account, or automation credential - with Kubernetes RBAC write permission specifically on Ingress resources (verbs: create, update, patch) in at least one namespace where NGINX Ingress Controller operates. The vulnerability is triggered only when Ingress annotations are present and processed by the controller; it is not exploitable from the NGINX data plane or by external unauthenticated actors. Key limiting factors: the requirement for Kubernetes API authentication with Ingress write permissions significantly constrains the attacker pool to trusted insiders, compromised CI/CD pipelines, or service accounts with overly broad RBAC bindings. Clusters enforcing strict least-privilege RBAC with Ingress write access limited to cluster administrators are substantially less exposed. |
| Impact | The CVSS 4.0 score of 8.7 (AV:N/AC:L/AT:N/PR:L/UI:N/VC:H/VI:H/VA:L/SC:N/SI:N/SA:N) accurately captures the risk profile: low access complexity once the required Kubernetes RBAC permissions are held, with high confidentiality and integrity impact on the Ingress Controller's control plane. The bounded scope - SC:N/SI:N/SA:N confirming no subsequent-system propagation - is an important moderating factor; downstream workloads behind the ingress are not directly compromised, though NGINX routing manipulation could disrupt service availability or redirect traffic. No public exploit code has been identified and the vulnerability is absent from CISA KEV, meaning active exploitation is currently unconfirmed. The realistic threat population is narrow: insiders, compromised CI/CD service accounts, or developers granted Ingress write permissions in shared Kubernetes clusters represent the primary risk vectors. Organizations running multi-tenant clusters with loosely scoped RBAC on Ingress resources should treat patching as urgent given the low complexity of exploitation once access conditions are met. |
| Exploit ScenarioDerived | An attacker holding a Kubernetes service account credential with RBAC write permission on Ingress resources in any namespace submits a crafted Ingress object whose annotation values contain embedded newlines and NGINX directives - for example, injecting a directive to include an attacker-writable file path or disable a location block. When NGINX Ingress Controller next regenerates its nginx.conf, the injected directives are included verbatim, causing NGINX to load an attacker-influenced configuration that may redirect traffic, expose files accessible to the NGINX process, or disable ingress routing. No public proof-of-concept has been identified, but the injection technique is well understood by anyone familiar with NGINX configuration syntax and Kubernetes annotation handling. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv2 – Sep 02, 2026
Annotation injection in F5 NGINX Ingress Controller allows any authenticated Kubernetes principal with write access to Ingress resources to embed arbitrary NGINX configuration directives through unsanitized annotation fields. The configuration generator passes multiple user-controllable annotation values directly into the generated nginx.conf without sanitization, enabling an attacker to inject directives that create or delete files, disable services, or manipulate NGINX routing behavior. Impact is confined to the Kubernetes control plane; the NGINX data plane itself is not directly reachable through this vulnerability.
Earlier versions of this analysis (1)
Configuration injection in F5 NGINX Ingress Controller allows authenticated Kubernetes users with Ingress annotation write access to embed arbitrary NGINX configuration directives into the controller's generated nginx.conf. Affected deployments span all reviewed versions of cpe:2.3:a:f5:nginx_ingress_controller:* that process Ingress annotations; the vendor confirms impact is confined to the Kubernetes control plane with no data plane exposure. No public exploit has been identified at time of analysis, but successful exploitation can result in arbitrary file creation or deletion, service disruption, and unauthorized NGINX configuration changes within the cluster.
RemediationAI
Consult F5 advisory K000162601 at https://my.f5.com/manage/s/article/K000162601 for the vendor-released patched version and upgrade instructions; no specific fix version was identified in the available intelligence data and should be obtained directly from F5. As a compensating control prior to patching, audit and tighten Kubernetes RBAC policies to restrict Ingress resource write permissions to only highly trusted principals (cluster administrators and explicitly approved automation accounts), removing Ingress write access from general developer or broad CI/CD service accounts. Deploy a Kubernetes admission controller such as OPA/Gatekeeper or Kyverno with a policy that rejects Ingress annotations containing suspicious characters including newlines, semicolons, and NGINX directive keywords; note that overly aggressive validation rules may reject legitimate annotation values and should be tested in staging. Audit all existing Ingress resources for anomalous annotation values as an immediate detection measure.
Affected VersionsENISA
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 1 package in euvd
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
NGINX Ingress Controller (CPE: cpe:2.3:a:f5:nginx_ingress_controller:*:*:*:*:*:*:*:*) is a widely deployed F5/NGINX Kubernetes controller that watches Ingress resources and translates their metadata - including annotations - into NGINX configuration files loaded by the NGINX process. The root cause is CWE-76 (Improper Neutralization of Equivalent Special Elements): annotation values containing NGINX configuration syntax characters (newlines, semicolons, braces, directive keywords) are written verbatim into the generated configuration template. Because NGINX configuration parsing is line- and block-structured, injecting a newline followed by arbitrary directives effectively inserts attacker-controlled configuration blocks into nginx.conf. This is architecturally a template-injection class of vulnerability within the config-generation pipeline, not a network-layer or protocol-level flaw. The Kubernetes API server mediates all access to Ingress resources, so RBAC controls are the primary enforcement boundary.
Know when Nginx Ingress Controller gets its next vulnerability
- Watch products and get an email when something new is published
- Check this CVE against your own stack and servers
- Exploit and PoC references, threat intelligence from 22 sources
No credit card · 7-day full trial
Severity by source
CVSS:4.0/AV:N/AC:L/AT:N/PR:L/UI:N/VC:H/VI:H/VA:L/SC:N/SI:N/SA:N
Requires Kubernetes RBAC write access to Ingress resources (PR:L, AC:L); scope unchanged as impact stays within the NGINX Ingress control plane (S:U); availability impact is low per vendor description.
Primary rating from Vendor (f5).
CVSS VectorVendor: f5
Lifecycle Timeline
4DescriptionCVE.org
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.
Articles & Coverage 1
Executive ViewAI
F5 NGINX Ingress Controller contains an annotation injection flaw that allows authenticated Kubernetes operators with Ingress resource write permissions to inject arbitrary NGINX configuration directives, potentially disrupting application routing, disabling services, or manipulating traffic flows. Affected organizations running NGINX Ingress Controller on Kubernetes clusters face risk to service availability and internal security posture from privileged internal actors.
No vendor-released patch identified at time of analysis. Interim mitigations: restrict Ingress resource write access via Kubernetes RBAC to minimal administrators; implement annotation validation policies using OPA or Kyverno to block NGINX directive keywords in annotation fields; enable and monitor Kubernetes audit logging for all Ingress modifications; enforce Pod Security Standards and network policies limiting the Ingress controller's runtime capabilities.
Threat Intelligence Overview
How this decision was reached
The engine reads each signal below and applies a fixed list of rules from top to bottom. The first rule that matches sets the recommended action – like a statement, every line is shown.
What every action level means
SSVC AssessmentENISA
Priority Score
Attack Technique
Code injection occurs when an application accepts user input and passes it directly into a language interpreter or evaluator without proper sanitization.
More in Nginx Ingress Controller
View allDenial of service against HTTP/2 server implementations allows remote unauthenticated attackers to exhaust server resour
Unauthenticated, remote attackers can bypass authentication and reach protected paths in F5 NGINX Kubernetes Ingress Con
Authentication bypass in F5 NGINX Ingress Controller allows unauthenticated remote attackers to access protected paths w
Configuration injection in F5 NGINX Ingress Controller lets an authenticated Kubernetes user with rights to create or mo
NGINX Open Source before versions 1.23.2 and 1.22.1, NGINX Open Source Subscription before versions R2 P1 and R1 P1, and
Denial of service in F5 NGINX Ingress Controller allows an authenticated remote attacker holding write access to Ingress
NGINX Open Source before versions 1.23.2 and 1.22.1, NGINX Open Source Subscription before versions R2 P1 and R1 P1, and
NGINX Plus before versions R27 P1 and R26 P1 have a vulnerability in the module ngx_http_hls_module that might allow a l
In versions 2.x before 2.3.0 and all versions of 1.x, An attacker authorized to create or update ingress objects can obt
NGINX proxy configurations forwarding traffic to upstream TLS servers can be exploited by network-positioned attackers t
A session fixation issue was discovered in the NGINX OpenID Connect reference implementation, where a nonce was not chec
EUVD-2026-70141
GHSA-rq28-44f4-q58q
NVD
CVE.org
EPSS
Vulnrichment
Exploit-DB