/

CVE-2026-33413

Severity:

HIGH RISK

(8.8)

Missing Authorization / Access Control in etcd Clusters

CVE-2026-33413

Analyzed

Vulnerability type

Category:

Missing Authorization / Access Control

CWE:

CWE-862

Impact:

Unauthorized Access to Sensitive Operations and Data, Potential Denial of Service

Severity:

HIGH RISK

(8.8)

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

etfd clusters that expose their gRPC API to untrusted or partially trusted clients may allow unauthorized users to invoke sensitive RPCs even when etcd authentication is enabled.

This missing authorization control can let attackers enumerate cluster topology, disrupt operations, interfere with leases and TTL-based keys, and trigger destructive compaction of historical data.

Affected context

This vulnerability affects etcd deployments that:

  • Enable etcd's built-in authentication/authorization, and
  • Expose the gRPC API directly to networks where untrusted or partially trusted clients can connect, and
  • Rely on etcd's own auth layer to gate access to sensitive RPCs such as MemberList, Alarm, Lease APIs, or compaction.

In many Kubernetes deployments, the API server intermediates access and etcd's internal auth is not used, which reduces practical exposure—but any environment that connects clients directly to etcd's gRPC endpoints is potentially at risk.

Exploit preconditions

  • Attack surface: etcd gRPC endpoints reachable over the network (typically the client or peer ports).
  • Required access: Ability for an unauthenticated or under-authenticated client to open a gRPC connection to the etcd server (e.g., from the same cluster network, misconfigured service, or exposed port).
  • Trigger point: Invocation of affected etcd RPCs (e.g., MemberList, Alarm, Lease operations, compaction) that should be protected by auth but are effectively callable without proper authorization.
  • Why exploitation is possible: Certain RPCs do not consistently enforce etcd's configured authentication and authorization checks, meaning that the server treats them as accessible even when auth is enabled. As a result, authorization is missing or incomplete (CWE-862) for these sensitive operations.

Why this happens

The core issue is incomplete enforcement of authorization logic on specific gRPC methods within etcd.

Although etcd provides an authentication and authorization subsystem intended to gate access to privileged functions, some RPCs (such as MemberList, Alarm, Lease operations, and compaction) can be invoked without the expected authorization checks when the gRPC interface is exposed.

This maps to CWE-862: Missing Authorization, where an application fails to verify that the actor is permitted to perform a given action, despite having a security mechanism in place.

From a design perspective, the authorization model is not consistently applied across all RPCs, creating an inconsistent protection boundary between authenticated and unauthenticated operations.

Potential impact

  • Unauthorized discovery of cluster topology, including member IDs and advertised endpoints, which can aid in further targeting or lateral movement.
  • Operational disruption or denial of service via misuse of the Alarm RPC, potentially interfering with cluster health and availability.
  • Interference with Lease APIs, including manipulating TTL-based keys, disrupting lease ownership, or destabilizing components that rely on leases for coordination or service discovery.
  • Triggering compaction operations that permanently remove historical revisions, breaking watch semantics and undermining audit trails and recovery workflows.
  • Indirect impact on higher-level systems that depend on etcd for configuration, coordination, or state management, leading to cascading outages or inconsistent state.

General mitigation guidance

Effective mitigation centers on narrowing trust boundaries, hardening access to etcd, and ensuring that sensitive operations are not exposed to untrusted clients:

  • Treat the affected RPCs as effectively unauthenticated and design deployments so only fully trusted components can reach etcd's gRPC interface.
  • Place etcd behind strict network segmentation and firewall rules, limiting inbound connections to known, trusted services (such as the Kubernetes API server in typical clusters).
  • Require strong, mutually authenticated transport (e.g., mTLS) between clients and etcd, with tightly scoped client certificates and minimal distribution of credentials.
  • Apply a least-privilege stance for all systems permitted to talk to etcd, ensuring no additional components or users can initiate direct gRPC connections.
  • Avoid exposing etcd client ports to the public internet or shared multi-tenant networks; treat etcd as a control-plane system needing high isolation.
  • Where possible, centralize access through intermediaries (e.g., an API server) that perform their own authentication and authorization instead of relying solely on etcd's internal auth.

How teams detect issues like this

Detecting and monitoring for this class of issue involves both configuration analysis and runtime observation:

  • Configuration review: Regularly audit etcd deployment manifests, systemd units, and Helm charts to verify that etcd client ports are bound only to internal interfaces and not exposed externally or to broad network segments.
  • Network policy enforcement: Use Kubernetes NetworkPolicies, firewalls, or service meshes to enforce that only designated components can reach etcd's gRPC endpoints, and verify these policies through periodic testing.
  • Static analysis and IaC scanning: Apply policy-as-code tools (e.g., for Kubernetes YAML, Terraform, or Ansible) to flag configurations where etcd is reachable from untrusted namespaces, networks, or services.
  • Log and telemetry monitoring: Monitor etcd access logs and gRPC telemetry for unexpected clients calling MemberList, Alarm, Lease, or compaction RPCs, especially from non-control-plane IP ranges or service accounts.
  • Security testing: Include directed tests in security assessments to check whether unauthenticated or low-privileged principals can successfully call sensitive etcd RPCs, and feed findings back into configuration baselines.

Sources

SourceLink
github.comgithub.com/etcd-io/etcd/security/advisories/GHSA-q8m4-xhhv-38mg

Frequently asked

questions

It can be, but only if etcd's gRPC ports are exposed beyond trusted networks or directly to the internet. In many production setups, etcd is reachable only from internal control-plane components, which limits remote exploitability. However, any misconfiguration that allows untrusted clients to connect to etcd significantly increases risk.

An attacker needs network-level access to the etcd gRPC interface. They do not need valid etcd credentials for the affected RPCs, because those calls lack proper authorization checks. Access can come from within the same cluster network, a peered environment, or any place where etcd ports are reachable.

The safest pattern is to ensure that only tightly controlled, trusted components can connect to etcd at all. This typically means isolating etcd on restricted networks, enforcing mutual TLS with carefully managed client certificates, and centralizing user-facing operations through an authenticated and authorized API layer rather than exposing etcd directly.

Architecturally, treat etcd and similar control-plane data stores as highly sensitive infrastructure. Apply defense-in-depth by:

  • Designing for strict network isolation and minimal exposure of low-level control services.
  • Enforcing strong authentication and authorization at both the transport and application layers.
  • Using infrastructure-as-code and policy-as-code to encode security requirements for service exposure.
  • Regularly reviewing and testing access controls on core components as part of security and reliability engineering practices.
Find out what's already
exploitable in your codebase.