/

CVE-2026-30956

Severity:

CRITICAL RISK

(9.9)

Improper Authorization in OneUptime Multi‑Tenant Access

CVE-2026-30956

Analyzed

Vulnerability type

Category:

Improper Authorization

CWE:

CWE-285, CWE-862

Impact:

Cross-Tenant Data Exposure and Account Takeover

Severity:

CRITICAL RISK

(9.9)

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

OneUptime versions prior to 10.0.21 contain an authorization bypass in their multi‑tenant access control that trusts client‑supplied HTTP headers to drive internal permission logic.

By forging the is-multi-tenant-query and projectid headers, a low‑privileged user can disable tenant scoping, access other tenants' project data, read sensitive user fields including plaintext password reset tokens, and ultimately reset passwords to fully take over victim accounts.

Affected context

This vulnerability arises in OneUptime deployments that:

  • Use the multi‑tenant access control system to segregate project and user data
  • Rely on HTTP request headers such as is-multi-tenant-query and projectid for authorization and tenant scoping
  • Do not independently verify those header values against authenticated session or server‑side context

In these conditions, authorization checks in BasePermission can be bypassed, causing cross‑tenant access to data that should be isolated per project or account.

Exploit preconditions

  • Attack surface: OneUptime HTTP API / web application endpoints that:
  • Consume is-multi-tenant-query and projectid headers
  • Rely on BasePermission for access control
  • Required access: Any authenticated, low‑privileged account in one tenant (e.g., basic project member).
  • Attacker capability: Ability to craft and send custom HTTP requests, including arbitrary headers, to OneUptime (e.g., via browser dev tools, curl, or an HTTP client).
  • Trigger point: Server‑side permission evaluation where:
  • is-multi-tenant-query is read from the client request
  • projectid is taken from the request headers to determine the target tenant/project
  • Why exploitation is possible: The permission system trusts client‑controlled headers to:
  • Decide whether a request is multi‑tenant
  • Choose which project/tenant context to operate under

As a result, internal BasePermission checks are skipped or mis‑scoped, effectively disabling tenant isolation and allowing attackers to query resources belonging to other tenants.

Why this happens

At its core, this issue is an improper authorization and missing authorization problem stemming from reliance on untrusted request metadata for security‑critical decisions.

Instead of deriving tenant and permission context exclusively from server‑validated sources (such as the authenticated user session, signed tokens, or server‑side mappings), OneUptime's access control logic:

  • Treats the is-multi-tenant-query header as a trusted switch that influences permission flow in BasePermission.
  • Uses client‑provided projectid to select the tenant/project context without fully verifying that the authenticated user is authorized for that project.

This aligns with:

  • CWE-285: Improper Authorization — permission checks exist but are implemented incorrectly, allowing users to perform actions outside their intended scope.
  • CWE-862: Missing Authorization — certain paths effectively skip necessary permission checks when the forged header values are present.

Abstractly, the insecure pattern is: "Trusting client‑controlled flags and identifiers to drive authorization branching and tenant scoping." When these flags can be forged, an attacker can redirect code paths into privileged behavior while still holding only low‑privileged credentials.

Potential impact

  • Cross‑tenant data exposure, where an attacker may read project data belonging to other organizations or customers.
  • Unauthorized access to sensitive user fields through nested relations (e.g., internal identifiers, contact data, or security‑relevant attributes).
  • Leakage of plaintext resetPasswordToken values for victim accounts.
  • Unauthorized password resets on victim accounts using exposed reset tokens.
  • Full account takeover of other users, including potentially administrative or high‑privilege accounts.
  • Escalation from a single compromised account to broad compromise of multiple tenants' data.

General mitigation guidance

Effective mitigation focuses on removing trust in client‑controlled headers for authorization decisions and enforcing server‑side tenant scoping:

  • Decouple authorization from headers:
  • Determine tenant, project, and user context exclusively from server‑side state (e.g., authenticated session, signed tokens, or database mappings).
  • Treat projectid and similar identifiers in the request as hints only, and always verify them against the authenticated user's allowed projects.
  • Eliminate client‑controlled security flags:
  • Avoid using request headers or parameters like is-multi-tenant-query as security‑critical toggles.
  • If mode switches are needed, derive them on the server based on the authenticated user's role and capabilities rather than trusting client input.
  • Enforce strict authorization checks:
  • Centralize permission logic in a single, well‑tested layer that:
  • Always checks resource ownership against the authenticated tenant.
  • Validates that the requested projectid belongs to the caller's tenant.
  • Ensure all read and write operations pass through this layer and cannot bypass it via alternate code paths.
  • Harden multi‑tenant boundaries:
  • Implement a strong tenant identifier that is bound cryptographically to the authentication token or session.
  • Enforce filtering by tenant at the data access layer (e.g., mandatory tenant filters on queries) so that cross‑tenant access cannot occur even if upper layers misbehave.
  • Least privilege and safe defaults:
  • Default to denying access when tenant context or authorization is ambiguous or inconsistent.
  • Avoid broad "multi‑tenant" shortcuts; require explicit, validated grants for cross‑tenant operations (if they are supported at all).
  • Security testing and review:
  • Include multi‑tenant authorization flows in threat models and design reviews.
  • Perform manual and automated tests that attempt to override tenant context using headers, query parameters, or body fields.

How teams detect issues like this

Organizations can pursue multiple strategies to detect this class of vulnerability in OneUptime‑like systems:

  • Static analysis patterns:
  • Flag code that:
  • Reads security‑relevant flags or tenant identifiers directly from headers (e.g., is-multi-tenant-query, projectid) and uses them in authorization branches.
  • Passes client‑supplied IDs directly into permission checks without resolving them from server‑side mappings.
  • Detect conditional logic that:
  • Skips or alters authorization paths based on request headers or query parameters.
  • Uses "multi‑tenant" or "bypass" flags to guard permission checks.
  • Code review signals:
  • Pay attention to:
  • Any use of client‑controlled data to select tenant or project context.
  • Permission checks inside framework classes (such as BasePermission) that can be disabled or altered by request metadata.
  • Functions that construct database queries using projectid or tenant IDs from headers without verifying ownership.
  • Review all endpoints that return user or project data for strong, consistent tenant scoping.
  • Runtime monitoring and logging:
  • Log:
  • Tenant and project IDs associated with each request.
  • The authenticated user ID and derived tenant context.
  • Alert on:
  • Requests where the header‑supplied tenant/project ID does not match the server‑derived tenant context.
  • Unusual access patterns, such as one user accessing many different project IDs in a short time.
  • Security testing and policy enforcement:
  • Incorporate automated tests in CI/CD that:
  • Attempt to alter tenant or project context by modifying headers and parameters.
  • Validate that cross‑tenant data is never accessible, even when client inputs are manipulated.
  • Use API gateways or service mesh policies to:
  • Normalize or strip non‑standard headers so that internal services do not treat them as trusted security controls.

Sources

SourceLink
github.comgithub.com/OneUptime/oneuptime/releases/tag/10.0.21
github.comgithub.com/OneUptime/oneuptime/security/advisories/GHSA-r5v6-2599-9g3m

Frequently asked

questions

This issue is broadly exploitable by any authenticated, low‑privileged user who can send crafted HTTP requests with custom headers. Because tenant scoping can be disabled or altered, a compromise of a single low‑privileged account may enable access to other tenants' data and accounts.

No. The vulnerability can be leveraged by low‑privileged accounts. The flaw lies in the permission system's trust of client‑controlled headers, not in a privileged feature; thus, even basic users can potentially gain cross‑tenant access and perform account takeovers.

The safest fix is to remove all reliance on client‑supplied headers or parameters for authorization decisions and tenant selection. Tenant and project context should be derived solely from the authenticated session or signed tokens, and every resource access must verify that the resource's tenant matches the caller's tenant, denying access by default when there is any mismatch or ambiguity.

To prevent similar issues:

  • Treat all client input (including headers) as untrusted and non‑authoritative for security decisions.
  • Design multi‑tenant systems so tenant context is enforced at the data access layer and derived from server‑validated state.
  • Use centralized authorization services or middleware that consistently apply tenant and permission checks.
  • Include multi‑tenant and header‑manipulation scenarios in threat modeling, automated tests, and security code reviews to catch design flaws before deployment.
Find out what's already
exploitable in your codebase.