/

CVE-2026-34759

Severity:

HIGH RISK

(8.1)

Missing Authorization in OneUptime Twilio Integration

CVE-2026-34759

Analyzed

Vulnerability type

Category:

Missing Authorization

CWE:

CWE-862

Impact:

Unauthorized Operations on Notification and Telephony Configuration

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

Multiple notification-related API endpoints in OneUptime are exposed without the expected authorization middleware, allowing unauthenticated access through the public Nginx proxy path /notification/.

When combined with a leaked projectId from the public Status Page API, an attacker can invoke these endpoints to purchase phone numbers on the victim's Twilio account and delete existing alerting numbers, disrupting notification workflows and incurring unwanted costs.

Affected context

The vulnerability affects OneUptime deployments where:

  • Notification service endpoints are exposed via the Nginx proxy under /notification/
  • Certain notification APIs are registered without ClusterKeyAuthorization.isAuthorizedServiceMiddleware or equivalent access control
  • Public Status Pages can leak or reveal valid projectId values
  • Twilio is configured as a notification provider for purchasing and managing phone numbers

In such environments, the notification endpoints may accept unauthenticated requests that the surrounding system implicitly assumes are restricted to authorized services or users.

Exploit preconditions

  • Attack surface: Publicly exposed HTTP(S) notification endpoints accessible via Nginx at /notification/.
  • Required access: No prior authentication is required; possession of a valid projectId associated with the target tenant is sufficient.
  • Trigger point: Issuing crafted HTTP requests to the unauthenticated notification APIs that manage Twilio phone numbers (e.g., purchase, delete operations).
  • Why exploitation is possible: Some notification routes were registered without the authorization middleware (ClusterKeyAuthorization.isAuthorizedServiceMiddleware) that sibling endpoints use. As a result, the service trusts direct calls from the internet as if they were from authorized components, and accepts projectId values from untrusted clients.

Why this happens

This issue stems from inconsistent enforcement of authorization checks on backend API routes, corresponding to CWE-862: Missing Authorization.

While sibling endpoints correctly apply ClusterKeyAuthorization.isAuthorizedServiceMiddleware, several notification endpoints omit this middleware, leaving them effectively unauthenticated yet still capable of performing privileged operations tied to a projectId. The design assumes these operations are invoked only by trusted internal services, but the routing configuration exposes them externally via Nginx under /notification/.

The combination of:

  • externally reachable service endpoints,
  • reliance on projectId as the primary tenant discriminator,
  • and missing authorization middleware

leads to a situation where untrusted clients can perform actions that should require strong authorization, such as provisioning and deleting Twilio numbers.

Potential impact

  • An attacker can purchase new phone numbers on the victim's Twilio account, potentially generating unwanted costs.
  • Existing alerting phone numbers can be deleted, disrupting incident response and monitoring notifications.
  • Notification reliability can be degraded or fully disabled for affected projects.
  • Victims may lose trust in the monitoring setup due to missed alerts and unexpected telephony behavior.
  • Twilio account configuration may be left in an inconsistent or unsafe state.

General mitigation guidance

Effective mitigation focuses on consistent, defense-in-depth authorization for all sensitive service endpoints:

  • Apply a mandatory authorization middleware (such as ClusterKeyAuthorization.isAuthorizedServiceMiddleware or equivalent) to all notification and configuration routes, including internal-like service APIs exposed behind Nginx.
  • Centralize route registration patterns so that new endpoints inherit authorization requirements by default rather than relying on ad-hoc middleware attachment.
  • Treat identifiers like projectId as untrusted input and require authenticated principals and role/permission checks before executing tenant-specific operations.
  • Enforce least privilege design: separate read-only from write/administrative operations on external providers (e.g., Twilio) and gate high-impact actions (purchase, delete, reconfigure) behind stricter policies.
  • Limit direct coupling between web-exposed routes and provider APIs by introducing service layers that enforce authorization and business rules consistently.

How teams detect issues like this

Teams can detect and prevent similar issues through a combination of code-level and architectural controls:

  • Static analysis and linters: Define rules that flag any route registration under sensitive prefixes (e.g., /notification/, /admin/) that lacks required authorization middleware.
  • Code review checklists: Require reviewers to verify that all new or modified endpoints explicitly declare authentication and authorization requirements, and that they align with sibling routes.
  • Security tests and API fuzzing: Use automated security testing to probe externally exposed paths for unauthenticated access to state-changing operations, especially around configuration and third-party integrations like Twilio.
  • Policy-as-code: Implement framework-level or gateway-level policies that enforce authentication and authorization on all non-public routes, making it difficult to introduce new unauthenticated state-changing endpoints.
  • Runtime monitoring: Log and alert on anomalous usage patterns, such as bursts of Twilio number purchases or deletions, particularly from unauthenticated or unusual sources.

Sources

SourceLink
github.comgithub.com/OneUptime/oneuptime/commit/9adbd04538714740506708d6fa610e433be4d2a4
github.comgithub.com/OneUptime/oneuptime/releases/tag/10.0.42
github.comgithub.com/OneUptime/oneuptime/security/advisories/GHSA-6wc5-rhvj-cx7f

Frequently asked

questions

Exploitation is possible wherever the vulnerable /notification/ endpoints are exposed via Nginx and a valid projectId can be obtained, typically from a public Status Page API. Under those conditions, an attacker does not need an account on the platform to abuse these APIs.

No, the affected endpoints do not enforce authentication via the expected middleware, so an attacker only needs network access to the API and knowledge of a target projectId to invoke notification operations.

The safest approach is to ensure that all state-changing notification and configuration endpoints are protected by a standardized authorization middleware, and that they verify both the authenticated principal and their permissions for the referenced projectId before performing Twilio-related actions.

Prevention relies on enforcing secure-by-default API design: require authentication and authorization for all endpoints unless explicitly marked as public, centralize route and middleware configuration, use automated checks to flag unprotected routes, and incorporate access control verification into code review and security testing practices.

Find out what's already
exploitable in your codebase.