/

CVE-2026-30855

Severity:

HIGH RISK

(8.8)

Authorization Bypass / Broken Access Control in WeKnora

CVE-2026-30855

Analyzed

Vulnerability type

Category:

Authorization Bypass / Broken Access Control

CWE:

CWE-284

Impact:

Cross-Tenant Account Takeover and Data Destruction

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

An authorization bypass in WeKnora's tenant management endpoints allows any authenticated user to read, modify, or delete arbitrary tenants by specifying their ID.

Because account creation is publicly accessible, an unauthenticated attacker can register an account and then perform cross-tenant account takeover and data destruction, making deployments highly exposed in multi-tenant environments.

Affected context

This vulnerability appears in WeKnora deployments operating in a multi-tenant mode where tenants are managed via HTTP APIs (e.g., REST/JSON) and tenant identifiers are client-controllable.

It is relevant when:

  • Tenant management endpoints (create, read, update, delete) are exposed to standard application users
  • Authorization checks are either missing or not bound to the caller's own tenant
  • Public self-service registration is enabled, allowing anyone to obtain an authenticated account

In such setups, tenant isolation relies entirely on proper per-tenant access control at the application layer.

Exploit preconditions

  • Attack surface: Public-facing web/API endpoints responsible for tenant lifecycle operations
  • Required access: Ability to authenticate as any user (which can be achieved by self-registering a new account)
  • Trigger point: Invoking tenant management endpoints while supplying the ID of a tenant controlled by another user or organization
  • Why exploitation is possible: The backend trusts the tenant ID from the request and only validates that the caller is authenticated, not that they are authorized to act on the referenced tenant, breaking isolation between tenants

Why this happens

The core issue is a missing or incomplete authorization check on tenant management operations.

Instead of enforcing that operations on a tenant resource are restricted to the owning user or administrative identities, the implementation accepts any authenticated user and applies actions based solely on a tenant identifier provided in the request.

This aligns with CWE-284: Improper Access Control, where resource-level authorization is not correctly implemented, resulting in horizontal privilege escalation across tenants.

Potential impact

  • An attacker can take over arbitrary tenants by updating configuration, ownership, or authentication-related settings.
  • Cross-tenant data exposure, including access to documents, embeddings, chat histories, and configuration.
  • Deletion or corruption of another tenant's data, including full tenant removal.
  • Disruption of service availability for targeted tenants or the entire deployment through bulk destructive actions.
  • Loss of trust and potential regulatory exposure due to unauthorized cross-organization data access.

General mitigation guidance

Effective mitigation centers on enforcing strict, resource-level authorization tied to tenant ownership and role-based access control:

  • Validate, on every tenant management request, that the caller is explicitly associated with the target tenant and has sufficient privileges for the requested action (read, update, delete).
  • Use server-side tenant context derived from the authenticated session or token, rather than trusting client-supplied tenant identifiers.
  • Implement least-privilege roles where tenant administration operations are limited to designated admin roles, not generic authenticated users.
  • Apply a consistent authorization layer or middleware so that all tenant-related endpoints automatically enforce the same policies.
  • Reduce exposure of administrative endpoints by separating them from general user-facing APIs where feasible.

How teams detect issues like this

Detection commonly involves a mix of code-centric and behavior-centric approaches:

  • Static analysis / code review: Look for tenant management routes that:
  • Do not verify ownership of the tenant resource
  • Accept tenant IDs directly from client input and act on them without additional checks
  • Rely solely on "is authenticated" checks for sensitive cross-tenant operations
  • Policy enforcement: Introduce architectural rules that any access to tenant-scoped resources must pass through a centralized authorization component or service.
  • Logging and monitoring: Monitor for suspicious patterns such as:
  • A single user account accessing or modifying many different tenant IDs
  • High volumes of delete or update operations against tenants
  • Automated testing: Add regression tests that attempt cross-tenant access with non-admin accounts to ensure isolation is preserved.

Sources

SourceLink
github.comgithub.com/Tencent/WeKnora/security/advisories/GHSA-ccj6-79j6-cq5q

Frequently asked

questions

Yes. Because account registration is public, a remote attacker can create an account and then exploit the authorization bypass over the network using the exposed tenant management APIs.

No. The issue arises precisely because any authenticated user, even one with a newly created low-privilege account, can operate on arbitrary tenant IDs.

Enforce strict per-tenant authorization on all tenant management endpoints, binding operations to the caller's tenant context on the server side and requiring appropriate roles (e.g., tenant admin) for sensitive actions such as updates and deletions.

Adopt a centralized authorization layer that all resource-handling routes must pass through, avoid trusting client-supplied identifiers for access decisions, write explicit tests for cross-tenant isolation, and integrate secure design reviews for all multi-tenant features.

Find out what's already
exploitable in your codebase.