/

CVE-2026-39429

Severity:

HIGH RISK

(8.2)

Missing Authentication and Authorization in kcp Cache Server

CVE-2026-39429

Analyzed

Vulnerability type

Category:

Missing Authentication and Authorization

CWE:

CWE-302, CWE-862

Impact:

Unauthorized Access and Data Tampering

Severity:

HIGH RISK

(8.2)

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

The kcp control plane exposed its cache server directly from the root shard without any authentication or authorization controls.

Anyone able to reach the root shard endpoint could read from and write to the cache server, potentially leading to unauthorized data access, tampering, or disruption of control plane behavior.

Affected context

This vulnerability affects kcp deployments where the root shard exposes the cache server directly on a reachable network interface.

In such environments, the cache server lacks both authentication and authorization checks, so any network principal that can connect to the root shard's cache endpoint can interact with its data.

The risk is higher in multi-tenant or shared infrastructure, or whenever the root shard is accessible from broader internal networks or cross-cluster connections rather than being strictly isolated.

Exploit preconditions

  • Attack surface: Network-accessible cache server exposed by the kcp root shard.
  • Required access: Ability to establish a network connection to the root shard's cache server (no credentials or tokens required).
  • Trigger point: Issuing read or write operations to the cache server API or protocol endpoints.
  • Why exploitation is possible: The cache server lacks both authentication (CWE-302) and authorization (CWE-862), so it trusts any client that can connect, treating all requests as fully privileged.

Why this happens

The underlying issue is the absence of access control enforcement on a sensitive backend component.

The cache server, which influences or reflects kcp control plane state, was exposed directly from the root shard without integrating standard authentication mechanisms (such as identity validation or token checks) and without enforcing authorization policies to limit what an authenticated principal may do.

This maps to CWE-302: Authentication Bypass by Assumed-Trusted Channel and CWE-862: Missing Authorization, where an internal service is incorrectly treated as implicitly trusted simply because it sits behind a particular network boundary.

Potential impact

  • Unauthorized reading of cached control plane data, including potentially sensitive configuration or state.
  • Unauthorized modification or deletion of cached entries, leading to data tampering.
  • Disruption of kcp behavior due to corrupted or inconsistent cache state.
  • Potential privilege escalation or lateral movement if cache contents influence access decisions elsewhere.
  • Denial-of-service conditions if the cache is flooded, poisoned, or rendered unusable.

General mitigation guidance

Effective mitigation focuses on enforcing clear trust boundaries and applying least-privilege access to internal components:

  • Require strong authentication for all direct cache server access, even when traffic originates from internal networks.
  • Apply fine-grained authorization checks so that only explicitly permitted principals can read or mutate cache entries.
  • Place the cache server behind a controlled service front-end (e.g., API gateway or sidecar) that centralizes authn/z policy enforcement.
  • Restrict network exposure of the root shard and cache server, limiting access to only the services that strictly require it.
  • Adopt secure-by-default configurations where internal components are not exposed without explicit, deliberate configuration.

How teams detect issues like this

Detection generally involves both configuration review and runtime monitoring:

  • Review deployment manifests and network policies to identify cache server endpoints that are directly exposed or lack authn/z configurations.
  • Use static or policy-as-code checks (e.g., admission controllers, IaC scanning) to flag services that bind to external interfaces without defined authentication or authorization layers.
  • Inspect logs and telemetry for anomalous cache access patterns, such as unknown clients, unusual read/write volumes, or access from unexpected network segments.
  • Include internal service access control checks in security architecture reviews, verifying that all control plane components sit behind consistent identity and policy enforcement.

Sources

SourceLink
github.comgithub.com/kcp-dev/kcp/releases/tag/v0.29.3
github.comgithub.com/kcp-dev/kcp/releases/tag/v0.30.3
github.comgithub.com/kcp-dev/kcp/security/advisories/GHSA-3j3q-wp9x-585p

Frequently asked

questions

It can be, depending on how the root shard is exposed. If the root shard or its cache server is reachable from outside a trusted boundary (e.g., over the internet or from untrusted networks), remote attackers could interact with the cache without any credentials. In more restricted environments, exploitation may be limited to internal or lateral attackers.

The attacker only needs network connectivity to the root shard's cache server endpoint. No authentication tokens, certificates, or Kubernetes credentials are required because the cache server does not enforce them.

Place the cache server behind a properly authenticated and authorized interface. Ensure all cache operations go through components that enforce identity verification and fine-grained authorization rules, and avoid exposing the raw cache service directly on shared or untrusted networks.

Design internal control plane components under a zero-trust assumption: no service should rely solely on its network location for trust. Require authenticated identities for all service-to-service calls, enforce consistent authorization policies, and validate through security reviews and automated checks that no sensitive backend is reachable without these controls.

Find out what's already
exploitable in your codebase.