/

CVE-2026-32254

Severity:

HIGH RISK

(7.1)

Improper Access Control in Kube-router Proxy

CVE-2026-32254

Analyzed

Vulnerability type

Category:

Improper Access Control

CWE:

CWE-284

Impact:

Unauthorized Network Reconfiguration / Traffic Redirection

Severity:

HIGH RISK

(7.1)

CVSS version:

3.1

Catch this CVE while code is being written

Detect vulnerable code directly in pull requests, so CVEs are fixed before merge.

Summary

Kube-router's proxy module fails to validate Kubernetes Service externalIPs and loadBalancer IPs before programming them into a node's network configuration.

Under certain cluster configurations, a malicious or overly-privileged user who can create or modify Services may be able to inject arbitrary external IPs into routing, potentially redirecting traffic or exposing internal services.

Affected context

This vulnerability affects Kubernetes clusters that use Kube-router as the networking solution, specifically when its proxy module is responsible for programming Service-related IPs onto nodes.

The risk is most relevant where:

  • Services use externalIPs or are exposed via load balancers
  • There is limited policy or admission control around which external IP ranges may be used
  • Users or service accounts have broad permissions to create or modify Services

In such environments, Kube-router may accept and apply unvalidated IPs into the node's network configuration.

Exploit preconditions

  • Attack surface: Kubernetes Service API objects processed by Kube-router's proxy module.
  • Required access: Ability to create or update Services with externalIPs or loadBalancer-related fields (either directly or through a CI/CD or operator component).
  • Trigger point: Submission or modification of a Service spec such that an attacker-controlled or out-of-policy IP address is set as an external or load balancer IP.
  • Why exploitation is possible: Kube-router does not validate or constrain these IP values against allowed ranges or policies before programming them into the node's networking configuration, so arbitrary IPs can be applied if the attacker holds sufficient Kubernetes RBAC permissions.

Why this happens

The root cause is an improper access control and validation gap in how Kube-router's proxy module treats Service external IP configuration.

Instead of enforcing constraints on which IP ranges are allowed or validating that externalIPs/loadBalancer IPs conform to cluster and network policy, the proxy logic assumes that any value present in the Service spec is legitimate and directly programs it into the node networking configuration.

This maps to CWE-284: Improper Access Control, because the system relies solely on Service-object permissions and does not implement additional authorization or validation layers around sensitive network configuration changes. The bug class is essentially "trusting declarative configuration too much" for critical routing decisions without enforcing boundaries or ownership of external address space.

Potential impact

  • Attackers may be able to redirect or hijack traffic destined for Services by binding arbitrary external IPs.
  • Internal-only Services could be unintentionally exposed to external networks through misconfigured externalIPs.
  • Cluster nodes may advertise or respond to IP addresses outside of intended ranges, creating routing anomalies or conflicts.
  • Network monitoring and access control systems can be bypassed or confused by unexpected external IP assignments.
  • In multi-tenant clusters, one tenant could potentially influence network exposure or routing of another tenant's services if RBAC is weakly configured.

General mitigation guidance

Effective mitigation generally focuses on constraining who can set external IPs and enforcing policy on allowed address ranges, rather than relying purely on component behavior:

  • Tighten RBAC for Service operations: Limit the ability to create or modify Services, especially the externalIPs and load balancer–related fields, to a small set of trusted operators or controllers.
  • Use admission control / policy engines: Enforce policies that restrict which IP ranges can be used for externalIPs and loadBalancer IPs, ensuring they match approved address spaces and cannot overlap with sensitive networks.
  • Leverage Kubernetes feature gates or configuration options: When possible, enable feature gates or configuration controls that disable or deny the use of externalIPs for general workloads and reserve them for controlled, audited use cases.
  • Apply network-layer safeguards: Implement BGP prefix filtering and network ACLs to ensure that nodes cannot advertise or respond to IP ranges outside of those explicitly authorized.
  • Adopt least-privilege operational patterns: Ensure that CI/CD pipelines, operators, and service accounts use minimal permissions and cannot arbitrarily expose services through external IPs.

How teams detect issues like this

Detection strategies can focus on both configuration and behavior:

  • Configuration auditing: Periodically scan Kubernetes Services for the presence of externalIPs and loadBalancer-specific IP fields, highlighting those that fall outside expected CIDR ranges or ownership.
  • Policy-based enforcement: Use admission controllers (e.g., validating webhooks, policy engines) to log or block creation of Services with out-of-policy IPs; monitor these logs for attempted violations.
  • Static and declarative review: Review Infrastructure-as-Code (Helm charts, Kustomize, manifests) for patterns that set externalIPs or statically assign loadBalancer IPs, especially in shared or multi-tenant namespaces.
  • Network monitoring: Observe BGP announcements and node network configurations for unexpected prefixes or addresses; alert on new external IPs bound on nodes that are not part of the approved allocation.
  • Automated configuration checks: Integrate cluster security scanners or custom scripts into CI/CD and periodic compliance checks to flag risky Service exposure patterns.

Sources

SourceLink
github.comgithub.com/cloudnativelabs/kube-router/commit/a1f0b2eea3ee0f66b9a5b5c49dcb714619ccd456
github.comgithub.com/cloudnativelabs/kube-router/releases/tag/v2.8.0
github.comgithub.com/cloudnativelabs/kube-router/security/advisories/GHSA-phqm-jgc3-qf8g

Frequently asked

questions

Indirectly. An external attacker would generally need to first compromise credentials or a workload with permissions to create or modify Services. Once that access is obtained, they could leverage the misconfigured externalIPs or loadBalancer IPs to influence how services are exposed or routed.

Exploitation requires the ability to create or update Kubernetes Service objects that Kube-router processes, particularly the fields related to externalIPs or load balancer IPs. This typically corresponds to elevated or operator-level RBAC permissions.

The safest pattern is to strictly limit who can define or modify externalIPs and loadBalancer IPs, enforce strong admission policies on allowed IP ranges, and ensure the networking stack validates external service IP configuration before applying it to nodes.

Adopt a defense-in-depth approach for networking configuration: enforce least-privilege RBAC, use policy engines to validate high-impact fields, treat any configuration that alters routing or external exposure as sensitive, and incorporate regular audits of Services and network policies into your security processes.

Find out what's already
exploitable in your codebase.