/

CVE-2026-27134

Severity:

HIGH RISK

(8.1)

Authentication and TLS Certificate Validation

CVE-2026-27134

Modified

Vulnerability type

Category:

Authentication and TLS Certificate Validation Misconfiguration

CWE:

CWE-287, CWE-295, CWE-296

Impact:

Improperly trusted client identities and unauthorized access via mTLS

Severity:

HIGH RISK

(8.1)

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

Strimzi versions 0.49.0 through 0.50.0 misconfigure mutual TLS (mTLS) trust when a custom Cluster or Clients CA is provided as a multistage CA chain, causing all CAs in the chain to be trusted for authentication.

Under these conditions, any user with a certificate signed by any CA in the chain may be able to authenticate to internal and user-configured Kafka listeners, expanding the trust boundary beyond what operators intended.

Affected context

The vulnerability appears in Strimzi-managed Kafka clusters running on Kubernetes or OpenShift that:

  • Use Strimzi versions 0.49.0 through 0.50.0
  • Configure a custom Cluster CA or custom Clients CA
  • Supply that CA as a multistage CA chain (multiple CAs in a chain), not as a single CA

In this configuration, the mTLS setup for both internal broker-to-broker communication and user-configured Kafka listeners trusts all CAs from the provided chain for client authentication.

Installations that rely on Strimzi-managed CAs or custom CAs consisting of a single CA certificate are not exposed to this specific issue, assuming they do not introduce other configuration errors.

Exploit preconditions

  • Attack surface: Kafka listeners configured for mutual TLS:
  • Internal Strimzi/Kafka inter-broker or component communication
  • User-configured external or internal Kafka listeners that rely on client certificate authentication
  • Required access: Ability to obtain a valid TLS client certificate issued by any CA contained in the configured CA chain, not just the intended issuing CA.
  • Trigger point: Establishment of a TLS connection where the Kafka listener performs client certificate verification based on the Strimzi-generated trust configuration.
  • Why exploitation is possible: The trust store used for mTLS is populated with all CAs from the provided chain, so the server accepts client certificates signed by any of those CAs. This breaks the assumption that only identities issued by a specific CA (or subset of the chain) can authenticate, effectively widening the authentication boundary beyond the operator's design.

Why this happens

At its core, this issue is a certificate and authentication misconfiguration arising from how Strimzi processes multistage CA chains when they are supplied as custom Cluster or Clients CAs.

Instead of selectively trusting only the intended CA that should issue client certificates, the configuration logic or trust-store construction treats all certificates in the chain as trust anchors. This means that intermediate or root CAs that were meant only for validation/chain building are also treated as authorities for authenticating clients.

This maps to:

  • CWE-295: Improper Certificate Validation – the system validates client certificates against a broader set of trust anchors than intended.
  • CWE-296: Improper Following of Certificate Chain – the full chain is not interpreted in the correct role hierarchy, causing all chain elements to be accepted as trust roots.
  • CWE-287: Improper Authentication – because mTLS is used for client authentication, misconfigured trust effectively weakens the authentication decision, allowing unauthorized identities to be accepted.

Conceptually, the insecure pattern is: using a complete CA chain as a set of trusted issuers for client authentication, rather than treating the chain as a validation path anchored in a specific, intentionally trusted CA.

Potential impact

  • Clients holding certificates signed by any CA in the configured chain may be able to authenticate, even if that CA was not intended to issue Kafka client identities.
  • Unauthorized internal or external services could gain authenticated access to Kafka brokers through mTLS.
  • Expansion of the cluster's effective trust boundary, potentially bridging separate PKI domains that operators believed to be isolated.
  • Increased risk of data exposure, such as consuming sensitive Kafka topics or producing untrusted data into critical streams.
  • Potential for lateral movement inside the Kubernetes/OpenShift environment when Kafka is used as a backbone between services across different trust domains.

General mitigation guidance

Effective mitigation focuses on tightening certificate trust configuration and treating CA chains with explicit intent:

  • Prefer single, clearly scoped issuing CAs for Kafka client authentication, avoiding multi-purpose CA chains unless their roles are well understood and intentionally trusted.
  • When a chain is required, ensure that application-level configuration or deployment logic selects only the specific CA(s) that should act as trust anchors for client authentication, rather than importing the full chain as trusted issuers.
  • Separate root CA responsibilities (anchor of trust) from intermediate CA responsibilities (issuance), and reflect that separation in the trust stores used by Kafka listeners.
  • Regularly review PKI design so that Strimzi/Kafka authentication aligns with organizational certificate policies and does not implicitly trust broader enterprise or external CAs than necessary.
  • Apply least-privilege principles to topics and client roles so that, even if a certificate is mis-trusted, its effective access within Kafka is constrained by authorization policies.

How teams detect issues like this

Organizations can look for this misconfiguration and related weaknesses using a combination of configuration inspection and policy-based checks:

  • Configuration review:
  • Examine Strimzi custom Cluster/Clients CA configuration to identify where full CA chains are provided instead of a single intended CA.
  • Inspect the resulting Kafka listener trust stores (e.g., content of truststore files) to verify whether multiple CAs are present and being used as trust anchors.
  • Policy and PKI audits:
  • Compare the CAs loaded into Kafka trust stores against the organization's PKI inventory to find unexpected or over-broad trust relationships.
  • Enforce policies that disallow multi-CA chains as direct trust sources for client authentication unless explicitly justified.
  • Static and automated checks:
  • Use infrastructure-as-code scanning or admission controllers to flag Strimzi CRs that embed multi-stage CA chains in custom CA fields.
  • Integrate automated review tools into CI/CD that can recognize certificate chain misuse patterns in deployment manifests or Helm charts.
  • Runtime verification:
  • In non-production environments, attempt connections with test client certificates issued by different CAs in the chain to validate that only the intended CA is actually trusted.

Sources

SourceLink
github.comgithub.com/strimzi/strimzi-kafka-operator/releases/tag/0.50.1
github.comgithub.com/strimzi/strimzi-kafka-operator/security/advisories/GHSA-2qwx-rq6j-8r6j
access.redhat.comaccess.redhat.com/security/cve/CVE-2026-27134
bugzilla.redhat.combugzilla.redhat.com/show_bug.cgi?id=2441564
security.access.redhat.comsecurity.access.redhat.com/data/csaf/v2/vex/2026/cve-2026-27134.json

Frequently asked

questions

Yes, if Kafka listeners are exposed (directly or via ingress/load balancers) and rely on mTLS for client authentication. Any party able to obtain a valid certificate from one of the CAs in the configured chain may be able to authenticate over the network, subject to network reachability and additional authorization controls.

The attacker needs the ability to obtain or control a TLS client certificate issued by any CA inside the configured multistage CA chain. They do not need access to Strimzi configuration itself; they only need to present a certificate that the misconfigured trust store accepts.

Configure Kafka's mTLS trust to rely only on the specific CA (or small set of CAs) that should issue client certificates for Kafka, rather than importing entire CA chains as trust anchors. In practice, that means supplying only the intended CA for client authentication and ensuring that trust stores do not implicitly treat every certificate in a chain as an issuer.

Treat PKI and mTLS configuration as security-critical code: design clear CA roles (root vs intermediate vs issuing), encode these roles in deployment policies, and use automation to enforce that only explicitly designated CAs become trust anchors. Combine this with periodic PKI and configuration audits, plus CI/CD checks that flag multi-CA chains or unexpected CAs in authentication trust stores.

Find out what's already
exploitable in your codebase.