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.isAuthorizedServiceMiddlewareor equivalent access control - Public Status Pages can leak or reveal valid
projectIdvalues - 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
projectIdassociated 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 acceptsprojectIdvalues 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
projectIdas 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.isAuthorizedServiceMiddlewareor 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
projectIdas 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.

