Summary
When Skipper is used as a Kubernetes Ingress controller, users with permission to create an Ingress and a Service of type ExternalName can abuse Skipper's network position to send requests to internal services not otherwise exposed.
By crafting specific ExternalName Services and Ingress rules, an attacker can turn Skipper into an unintended network proxy, potentially bypassing network segmentation and accessing sensitive internal endpoints.
Affected context
This vulnerability occurs in Kubernetes environments where Skipper is deployed as an Ingress controller and:
- Users or workloads can create or modify Ingress resources
- Users or workloads can create or modify Services of type
ExternalName - Skipper is allowed to resolve and route traffic to arbitrary ExternalName targets (e.g., DNS names inside the cluster or on internal networks)
Under these conditions, Skipper's privileged network location allows it to act as a bridge to internal services that would not normally be reachable directly from the attacker's position.
Exploit preconditions
- Attack surface: Kubernetes API via standard resource creation (Ingress + Service of type ExternalName).
- Required access: Ability to create or update:
- An Ingress resource handled by Skipper, and
- A Service of type
ExternalNamein the same cluster/namespace pattern. - Trigger point: HTTP(S) requests flowing through Skipper to routes bound to ExternalName Services, typically via public or semi-public ingress endpoints.
- Why exploitation is possible: Skipper trusts and uses the ExternalName target specified in the Service without sufficient restrictions, effectively allowing an attacker to control Skipper's outbound request destination and leverage its internal network visibility.
Why this happens
The underlying issue is a combination of CWE-918: Server-Side Request Forgery (SSRF) and CWE-441: Unintended Proxy or Intermediary behavior in a network control plane component.
Skipper, running with access to internal networks, honors ExternalName Service definitions that can point to arbitrary hostnames. When an attacker can influence these definitions, they can steer Skipper's outbound traffic to sensitive internal services (e.g., internal APIs, metadata services, or management interfaces).
Conceptually, the bug arises from treating user-controlled routing metadata (Ingress + ExternalName configuration) as inherently trustworthy, without applying strong allow-listing, scoping, or policy checks on where Skipper is allowed to send traffic. This turns Skipper into an unintentional, attacker-controlled internal proxy.
Potential impact
- Access to internal HTTP(S) services that are not directly exposed to the attacker
- Potential interaction with cloud metadata or management endpoints reachable from Skipper's network context
- Bypass of network segmentation or firewall rules designed to protect internal resources
- Use of Skipper as a pivot point for further reconnaissance inside the cluster or internal network
- Possible exfiltration of sensitive data returned by internal services through the ingress response path
General mitigation guidance
Effective mitigation focuses on constraining where Skipper is allowed to forward traffic and reducing the trust placed in user-controlled routing configuration:
- Prefer disabling or heavily restricting the use of
ExternalNameServices for Ingress routing, especially for untrusted namespaces or tenants. - Apply strict allow-listing of permissible ExternalName targets (e.g., specific hostnames, domains, or internal FQDN patterns), ideally enforced centrally rather than per-team.
- Introduce policy controls that distinguish between trusted and untrusted configuration sources, limiting which namespaces or roles may define routes that reach internal resources.
- Use network policies, service meshes, or firewall rules so that Skipper's outbound traffic can only reach explicitly approved destinations aligned with its intended role.
- Design routing configuration patterns that default to minimal reachability and require explicit justification and review for any access to sensitive internal services.
These measures aim to ensure that even if an attacker can create Ingress and ExternalName resources, they cannot redirect Skipper's traffic to arbitrary internal endpoints.
How teams detect issues like this
Detection efforts can focus on both configuration and runtime behavior:
- Configuration analysis:
- Periodically scan cluster resources for Services of type
ExternalName, especially those referencing internal hostnames or unexpected domains. - Use policy engines (e.g., admission controllers, OPA/Gatekeeper, Kyverno) to flag or block ExternalName definitions that target sensitive namespaces, domains, or IP ranges.
- Implement static checks in CI/CD for Kubernetes manifests that create ExternalName Services or Ingress rules with unusual targets.
- Runtime monitoring:
- Monitor Skipper's outbound traffic for connections to unexpected internal services or domains that are not part of approved architecture diagrams.
- Use network flow logs or service mesh telemetry to detect suspicious routes originating from Skipper to protected networks.
- Set up alerts for sudden changes in ExternalName-based routing or spikes in traffic to rarely used internal endpoints.
- Code/review signals:
- During reviews of Ingress-related infrastructure code, pay attention to patterns that expose routing decisions to untrusted users or namespaces.
- Employ automated tools that flag potential SSRF-like behavior when a component with broad network visibility resolves user-controlled hostnames.

