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
externalIPsor 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
externalIPsor 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
externalIPsand 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
externalIPsand 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
externalIPsor 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.

