Summary
The Air Traffic Controller (ATC) component in Yoke exposes Kubernetes AdmissionReview webhook endpoints without proper authentication, allowing any pod in the cluster network to call them directly.
An attacker who can run or compromise a pod in the cluster may trigger arbitrary WASM module execution in the ATC controller context, bypassing Kubernetes API Server authentication and authorization controls.
Affected context
This vulnerability affects Yoke deployments using the Air Traffic Controller (ATC) webhook component in environments where:
- The ATC webhook service is reachable from other pods within the cluster network
- AdmissionReview-style endpoints are exposed for policy or deployment decisions
- No mutual TLS, authentication token, or request identity verification is enforced between the API Server and the ATC webhook
In such setups, the webhook implicitly trusts any AdmissionReview-like request originating from inside the cluster network instead of verifying that it comes via the Kubernetes API Server.
Exploit preconditions
- Attack surface: Network-exposed ATC webhook endpoints inside the Kubernetes cluster.
- Required access: Ability to run or compromise a pod that can reach the ATC webhook service over the cluster network (e.g., ClusterIP, service DNS).
- Trigger point: Sending crafted AdmissionReview requests directly to the ATC webhook endpoints, emulating the Kubernetes API Server callback.
- Why exploitation is possible: The webhook does not enforce authentication or strong request identity checks, so it treats any well-formed AdmissionReview request as trusted and executes associated WASM modules in the ATC controller context.
Why this happens
The core problem is a lack of authentication and request identity validation on sensitive webhook endpoints.
The ATC component assumes that only the Kubernetes API Server will invoke its AdmissionReview webhook, but it does not cryptographically verify caller identity (for example via mTLS, service account validation, or a shared trust mechanism).
This maps to CWE-306: Missing Authentication for Critical Function, where a security-sensitive operation—here, executing WASM modules based on AdmissionReview requests—is exposed without verifying that the caller is authorized to invoke it.
At a design level, the webhook equates "reachable over the cluster network" with "trusted," which is an insecure trust boundary assumption for multi-tenant or potentially compromised cluster environments.
Potential impact
- Attackers may trigger arbitrary WASM module execution in the ATC controller context.
- Malicious pods could influence or override admission decisions for resources managed by Yoke.
- Lateral movement by escalating from a compromised workload pod into the Yoke control plane component.
- Integrity compromise of IaC-driven deployments, including unauthorized configuration changes or policy bypasses.
- Potential for denial of service by flooding the webhook with expensive or malformed requests.
General mitigation guidance
Mitigation generally focuses on enforcing strong authentication and tightening network and trust boundaries for admission webhooks:
- Require mutual TLS (mTLS) between the Kubernetes API Server and the ATC webhook, validating both client and server identities.
- Strictly validate that incoming AdmissionReview requests originate from the expected API Server identity or trusted service account, rejecting all others.
- Isolate the ATC webhook behind cluster network policies or service meshes that permit access only from the API Server or approved control-plane components.
- Implement explicit authorization checks for each webhook invocation, based on caller identity and intended operation.
- Apply least-privilege to the ATC controller's own permissions so that any misuse of the webhook has a constrained blast radius.
- Design webhook handlers to fail closed when identity, integrity, or request origin cannot be validated.
How teams detect issues like this
Detection and assurance efforts can focus on both code-level and runtime signals:
- Static analysis / code review:
- Identify HTTP handlers in control-plane components that execute code or make admission decisions without authenticating the caller.
- Flag webhook implementations where client certificates, tokens, or request headers are not validated before processing AdmissionReview payloads.
- Look for assumptions such as "internal network == trusted" in design docs or comments.
- Configuration and policy review:
- Inspect webhook configurations for use of mTLS and verify that only the Kubernetes API Server endpoints are allowed as clients.
- Use Kubernetes NetworkPolicies or service mesh policies to confirm that only authorized namespaces or identities can reach the webhook service.
- Runtime monitoring:
- Log and monitor incoming webhook requests, including source IPs, service accounts, and namespaces.
- Alert on webhook access from unexpected workloads, namespaces, or identities.
- Automated tooling:
- Incorporate security scanners or admission control policy tools that specifically check for unauthenticated internal webhooks and missing client auth on critical services.

