/

CVE-2026-35053

Severity:

CRITICAL RISK

(9.8)

Missing Authentication in OneUptime Worker Service

CVE-2026-35053

Analyzed

Vulnerability type

Category:

Missing Authentication

CWE:

CWE-306

Impact:

Unauthenticated Remote Workflow Execution and Data Manipulation

Severity:

CRITICAL RISK

(9.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

The OneUptime Worker service exposes manual workflow execution endpoints without authentication, allowing anyone who can obtain or guess a workflow ID to trigger its execution.

This can lead to attacker-controlled workflow runs, including arbitrary JavaScript code execution within workflows, notification abuse, and unauthorized data manipulation.

Affected context

This vulnerability affects OneUptime deployments where the Worker service's ManualAPI is reachable over a network (internal or external) and the endpoints:

  • GET /workflow/manual/run/:workflowId
  • POST /workflow/manual/run/:workflowId

are exposed. The issue manifests when these routes are registered without any authentication or authorization middleware, allowing requests from any caller that can connect to the service and supply a workflow ID. The risk is amplified in environments where workflow definitions can execute JavaScript, send notifications, or modify monitored data.

Exploit preconditions

  • Attack surface: Network-accessible OneUptime Worker service exposing the ManualAPI endpoints.
  • Required access: Ability to send HTTP requests to /workflow/manual/run/:workflowId (GET or POST); no valid account or credentials are required if the issue is present.
  • Knowledge needed: A valid workflowId, which may be guessable, discoverable via enumeration, logs, UI references, or shared documentation.
  • Trigger point: Direct invocation of the manual workflow run endpoints with attacker-chosen input in the request body or query parameters.
  • Why exploitation is possible: The endpoints responsible for executing workflows are not protected by authentication middleware, so the service does not verify caller identity or permissions before running the workflow with supplied data.

Why this happens

The root cause is a missing authentication and authorization check on high-privilege API endpoints responsible for executing workflows. This aligns with CWE-306: Missing Authentication for Critical Function, where a sensitive operation is exposed without verifying the caller's identity.

In architectural terms, the Worker service's ManualAPI treats workflow execution as a public operation, failing to enforce:

  • Authentication (who is making the request)
  • Authorization (whether that caller is allowed to run the specified workflow)

Because the design allows arbitrary input data to be passed into workflows, any unauthenticated caller can effectively drive internal logic, including JavaScript execution, outbound notifications, or state changes, as if they were a trusted operator.

Potential impact

  • Unauthenticated execution of arbitrary workflows by anyone who can reach the Worker service.
  • Attacker-controlled JavaScript execution within workflow steps that support scriptable logic.
  • Abuse of notification channels (email, SMS, messaging integrations) for spam, phishing, or alert fatigue.
  • Unauthorized modification or corruption of monitoring data, incident records, or operational metadata.
  • Indirect access to connected third-party systems or integrations via misused workflow actions.
  • Potential pivoting into broader infrastructure depending on what workflows are allowed to do.

General mitigation guidance

Effective mitigation centers on enforcing strict access control around workflow execution and treating it as a privileged capability:

  • Require robust authentication for all workflow execution endpoints, using centrally managed middleware or API gateway policies rather than per-route ad hoc checks.
  • Apply principle of least privilege to workflow operations, ensuring only authorized roles or service accounts can trigger manual runs, and ideally scoping access to specific workflows.
  • Introduce an explicit authorization layer for workflow execution that validates whether a caller is allowed to invoke the target workflow ID.
  • Treat workflow input as untrusted, validating and constraining it before use, especially when it feeds scriptable or dynamic logic.
  • Consider adding configuration switches that disable manual workflow execution endpoints in environments where they are not required.
  • Where workflows support JavaScript or other scripting, sandbox or constrain that execution and limit access to sensitive APIs to reduce blast radius if workflows are abused.

How teams detect issues like this

To detect similar issues and assess exposure, organizations can:

  • Use static analysis or route-introspection tools to flag HTTP endpoints that modify state or execute workflows but lack authentication middleware or access-control attributes.
  • Incorporate security-focused code review checklists that highlight any new "execute", "run", "trigger", or "manual" workflow/automation endpoints for explicit authz review.
  • Add API gateway or service mesh policies that require authentication for all non-idempotent or high-impact routes, and monitor for exceptions.
  • Analyze access logs for unexpected or unusual calls to /workflow/manual/run/:workflowId, particularly from unknown IPs or outside expected automation accounts.
  • Employ application-level security testing (DAST) to probe for unauthenticated access to workflow, job, or automation execution APIs.

Sources

SourceLink
github.comgithub.com/OneUptime/oneuptime/releases/tag/10.0.42
github.comgithub.com/OneUptime/oneuptime/security/advisories/GHSA-6c3w-7xg4-4cf7

Frequently asked

questions

It can be, if the OneUptime Worker service or a reverse proxy exposing /workflow/manual/run/:workflowId is reachable from the internet. In more restricted deployments, exploitation may still be possible from inside the network if internal access is not tightly controlled.

No. The core issue is the absence of authentication on the manual workflow run endpoints. Any party that can reach those endpoints and knows or guesses a valid workflow ID can attempt exploitation, regardless of whether they have an account.

The safest pattern is to ensure all critical operations—such as workflow/job execution—are protected by centralized authentication and authorization mechanisms. Every such endpoint should explicitly verify the caller's identity and check permissions before executing logic, rather than relying on implicit trust or network location.

Prevention typically involves designing APIs with "secure by default" access control: mandate authentication for all non-read-only endpoints, enforce least-privilege authorization, codify access-control requirements in API design guidelines, and use automated checks (static analysis, API linting, and gateway policies) to flag routes that handle sensitive actions without appropriate protections.

Find out what's already
exploitable in your codebase.