/

CVE-2026-25999

Severity:

HIGH RISK

(7.1)

Improper Access Control in Klaw Kafka Governance Portal

CVE-2026-25999

Analyzed

Vulnerability type

Category:

Improper Access Control

CWE:

CWE-285

Impact:

Unauthorized Metadata Reset and Service Disruption

Severity:

HIGH RISK

(7.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

Klaw versions prior to 2.10.2 contain an improper access control issue on the /resetMemoryCache endpoint that lets unauthorized users trigger a reset or deletion of in-memory metadata for any tenant.

By sending a crafted request, an attacker can clear cached configurations, environments, and cluster data, potentially disrupting governance workflows and causing inconsistent system behavior.

Affected context

The vulnerability resides in Klaw's web API layer, specifically in the endpoint responsible for resetting in-memory caches related to tenant metadata, configurations, environments, and cluster information.

It is relevant where Klaw is deployed as a management/governance portal for Apache Kafka and the /resetMemoryCache endpoint is reachable from user-accessible networks (internal or external).

The issue typically appears when the endpoint is deployed without strict authorization checks or relies solely on network position or UI paths for protection instead of robust, role-based access control.

Exploit preconditions

  • Attack surface: HTTP(S) API endpoint /resetMemoryCache exposed by the Klaw application
  • Required access: Network access to the Klaw server; ability to send crafted HTTP requests (may not require authentication if access control is missing or weak)
  • Trigger point: Invocation of the /resetMemoryCache endpoint with parameters targeting specific tenant metadata or global caches
  • Why exploitation is possible: The endpoint does not sufficiently enforce authorization or tenant scoping, allowing a caller without appropriate privileges to perform cache reset operations that affect any tenant

Why this happens

This vulnerability is an instance of CWE-285: Improper Authorization, where a security-sensitive operation is exposed without adequate checks to verify the caller's permissions.

The reset-memory-cache functionality, which controls in-memory state for configuration and environment metadata, is treated as if it were a benign maintenance operation rather than a privileged administrative action.

As a result, the code path that handles /resetMemoryCache either:

  • Omits authorization checks entirely, or
  • Performs incomplete checks that do not confirm the user's role, tenant ownership, or intended scope of impact.

Abstractly, this reflects the insecure pattern of exposing powerful maintenance or administrative endpoints without consistent use of a centralized authorization mechanism and clear privilege boundaries.

Potential impact

  • Unauthorized clearing of cached configurations for any tenant, leading to temporary loss of visibility or control in the portal
  • Disruption of Klaw-based workflows (approvals, topic governance, and environment management) due to missing or reloaded metadata
  • Inconsistent behavior between in-memory state and persistent data sources, potentially causing user confusion or misconfiguration
  • Potential indirect impact on Kafka topic governance decisions, if operators act on incomplete or outdated metadata
  • Increased operational load as caches are repopulated, potentially affecting performance during repeated abuse

General mitigation guidance

Effective mitigation centers on treating cache-reset functionality as a privileged administrative operation and enforcing consistent authorization and scoping:

  • Require strong, role-based access control for all maintenance endpoints, including /resetMemoryCache, ensuring only explicitly authorized administrative roles can invoke them.
  • Centralize authorization logic so that every security-sensitive endpoint passes through a uniform permission-checking layer, reducing the risk of ad-hoc bypasses.
  • Apply least privilege by designing roles that separate configuration governance from system-level maintenance; not every authenticated user should have cache-reset capabilities.
  • Limit the scope of reset operations where possible (e.g., tenant-scoped or entity-scoped resets) and verify the caller's ownership or administrative authority over the target scope.
  • Consider adding defense-in-depth controls such as CSRF protection for state-changing operations via web interfaces, and require additional confirmation or auditing for high-impact admin actions.
  • Harden network exposure by restricting access to administrative endpoints to controlled networks or management planes, reducing the number of potential callers even if application-level controls fail.

How teams detect issues like this

Detection typically combines application-layer monitoring, code analysis, and policy enforcement:

  • Static analysis and code review:
  • Search for controller or route handlers implementing /resetMemoryCache and verify they consistently invoke centralized authorization checks.
  • Flag any security-sensitive endpoints that:
  • Are reachable without authentication, or
  • Do not enforce role/permission checks before performing state-altering operations.
  • Review annotations, middleware configuration, and security filters to ensure that maintenance endpoints are included in protected URL patterns.
  • Runtime monitoring and logging:
  • Enable detailed logging for calls to /resetMemoryCache, including caller identity, source IP, tenant context, and timestamp.
  • Create alerts for unusually frequent cache reset operations, resets initiated by non-admin accounts, or resets occurring outside normal maintenance windows.
  • Policy and configuration checks:
  • Use automated security testing (e.g., DAST, API fuzzers) to probe for unauthenticated or low-privileged access to administrative or maintenance endpoints.
  • Enforce internal security policies that require explicit authorization annotations or filters for any endpoint that can modify global or cross-tenant state.

Sources

SourceLink
github.comgithub.com/Aiven-Open/klaw/commit/617ed96b1db111ed498d89132321bf39f486e3a1
github.comgithub.com/Aiven-Open/klaw/releases/tag/v2.10.2
github.comgithub.com/Aiven-Open/klaw/security/advisories/GHSA-rp26-qv9w-xr5q

Frequently asked

questions

Yes, if the Klaw instance exposes the /resetMemoryCache endpoint to networks accessible by an attacker. Exploitation occurs over HTTP(S) by calling the endpoint without having the intended administrative privileges.

It depends on the specific deployment and access control configuration. The core issue is that the endpoint does not adequately enforce proper authorization; in some setups, this might mean unauthenticated access, while in others, any low-privileged authenticated user could trigger the reset.

The safest approach is to enforce strict, role-based authorization for /resetMemoryCache and any similar maintenance endpoints, ensuring they can only be used by designated administrative roles. Centralized authorization mechanisms should be applied consistently to all state-changing and cross-tenant operations.

Prevent recurrence by adopting a security-by-design approach for all new endpoints: classify operations by sensitivity, require explicit authorization for any action that affects global or tenant-wide state, and enforce these rules through centralized security middleware, automated tests, and code review checklists focused on access control.

Find out what's already
exploitable in your codebase.