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-queryandprojectidfor 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-queryandprojectidheaders - Rely on
BasePermissionfor 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-queryis read from the client requestprojectidis 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-queryheader as a trusted switch that influences permission flow inBasePermission. - Uses client‑provided
projectidto 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
resetPasswordTokenvalues 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
projectidand 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-queryas 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
projectidbelongs 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
projectidor 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.

