Sanaan Fayaz Wani

triggerdotdev/trigger.dev

GHSA-jc26-22qp-cgqj

Supervisor workload API lacks cross-tenant authentication

GHSA-jc26-22qp-cgqj

7.9

High

CVSS 3.1 base

  1. 2026-05-22Reported privately
  2. 115 days later2026-09-14Published by the maintainer

What to do

If you run trigger.dev 4.6.0 and earlier, the advisory lists 4.6.0 as both affected and fixed, so confirm the fixed release with the maintainer.

Anyone on an adjacent network, with a low-privilege account and no user interaction, given conditions outside the attacker's control, can read and change sensitive data and degrade its availability, and the impact reaches beyond the vulnerable component.Read from the CVSS 3.1 vector

CVSS 3.1 metrics

To exploit it

Attack vector
Adjacent
Attack complexity
High
Privileges required
Low
User interaction
None

What it gets

Confidentiality
High
Integrity
High
Availability
Low
Scope
Changed

Open this vector in the FIRST calculator ↗

Weakness
CWE-306 Missing Authentication for Critical Functionality
CVE
not assigned
Vector
CVSS:3.1/AV:A/AC:H/PR:L/UI:N/S:C/C:H/I:H/A:L
Also in trigger.dev
GHSA-59h8-w5q6-mfmp 5.3 · GHSA-pqxw-g93w-hj9x 8.1
2026-05-22Reported privately
115 days
2026-09-14Published by the maintainer

My analysis of this finding: root cause, the vulnerable code, the impact and the fix, in the site’s format. The official advisory of record is linked above.

Affected versions

Package Ecosystem Vulnerable Fixed in
trigger.dev npm <= 4.6.0 >= 4.6.0

Summary

The trigger.dev supervisor runs a workload server (default port 8020, bound to 0.0.0.0) that drives the entire run lifecycle: starting attempts, completing them, heartbeating, suspending, continuing, and dequeuing work. Every HTTP route on this server in apps/supervisor/src/workloadServer/index.ts executes with zero authentication, and the WebSocket namespace only checks that two headers are present, never that they carry a secret. Any party that can reach the port can manipulate any run by its friendlyId.

Where it lives

The server is constructed to listen on all interfaces by default:

constructor(opts: WorkloadServerOptions) {  super();  const host = opts.host ?? "0.0.0.0";  const port = opts.port;  ...

The buglistens on all interfaces by default

Each lifecycle route takes a runFriendlyId and a snapshotFriendlyId from the URL and immediately calls the worker client. There is no bearer check, no shared secret, no mutual TLS. For example, the attempt start route:

.route(  "/api/v1/workload-actions/runs/:runFriendlyId/snapshots/:snapshotFriendlyId/attempts/start",  "POST",  {    paramsSchema: WorkloadActionParams,    bodySchema: WorkloadRunAttemptStartRequestBody,    handler: async ({ req, reply, params, body }) => {      const startResponse = await this.workerClient.startRunAttempt(        params.runFriendlyId,        params.snapshotFriendlyId,        body,        this.runnerIdFromRequest(req)      );

The bugcalls the worker client with no credential checkThe bugrunner id comes from an unverified request header

The same shape repeats for /attempts/complete, /heartbeat, /suspend, /continue, /snapshots/since, and /deployments/:deploymentId/dequeue. The only identity signal is a runnerId pulled from a request header, used for bookkeeping, not verified against anything.

The WebSocket side is no better. The namespace middleware only copies two headers into socket data and disconnects if they are missing:

setSocketDataFromHeader("deploymentId", WORKLOAD_HEADERS.DEPLOYMENT_ID);setSocketDataFromHeader("runnerId", WORKLOAD_HEADERS.RUNNER_ID);...this.logger.debug("[WS] auth success", socket.data);

The bugheader presence alone counts as auth success

Presence of a header is treated as authentication. Both values are attacker suppliable.

Impact

Run lifecycle hijack. An attacker on the network forges requests for any known runFriendlyId and snapshotFriendlyId pair. They can mark attempts complete with attacker chosen results, force completion or failure, spoof heartbeats to keep dead runs alive or let live ones expire, and trigger suspend and continue transitions out of order.

Work theft and injection. The dequeue route hands out queued work for a deployment to anyone who asks, so an attacker can pull pending runs intended for legitimate runners. Combined with the complete route, this lets an attacker intercept a run and return forged output as the task result.

This is a direct consequence of the supervisor trusting its network. On the default self-hosted stack the runner containers share that network, so the exposure is reachable, not theoretical.

Fix

Require a real credential on every workload route and on the WebSocket handshake. The deployment already provisions a MANAGED_WORKER_SECRET; verify it (or a per runner token) on each request instead of merely reading the runnerId header. Stop treating header presence as authentication in the socket middleware, and bind the server to a private interface rather than 0.0.0.0 unless an authenticated gateway sits in front of it.

The record

Weakness
CWE-306 Missing Authentication for Critical Functionality
Affected
trigger.dev 4.6.0 and earlier
Fixed in
Unclear in the record
Disclosure
2026-05-22 Reported privately
115 days later2026-09-14 Published
Advisory
GHSA-jc26-22qp-cgqj
Also in trigger.dev
GHSA-59h8-w5q6-mfmp 5.3
GHSA-pqxw-g93w-hj9x 8.1

About this writeup

Sanaan Fayaz Wani (GitHub sfwani) reported this vulnerability to the trigger.dev maintainers under coordinated disclosure and is credited as a reporter in GHSA-jc26-22qp-cgqj, published 2026-09-14.

All published findings: advisory index.