Skip to main content
Vulnerability Database/CVE-2026-114085

CVE-2026-114085: Trigger.dev Auth Bypass Vulnerability

CVE-2026-114085 is an authentication bypass flaw in Trigger.dev that allows attackers to manipulate runs across deployments without proper verification. This post explains its impact, affected versions, and mitigation steps.

Published:

Disclaimer: This content was generated using AI. While we strive for accuracy, please verify critical information with official sources.

Sources: National Vulnerability Database, CISA KEV, Exploit-DB

CVE-2026-114085 Overview

CVE-2026-114085 is a missing authentication vulnerability [CWE-306] in Trigger.dev through version 4.7.6. The flaw resides in the supervisor workload server, which fails to verify ownership when workloads request operations on runs. Attackers with network access and a valid run/snapshot pair can manipulate runs belonging to other deployments. Exploitation lets an attacker call the attempts/start endpoint to retrieve resolved environment variables and run JSON Web Tokens (JWTs), or start, complete, and suspend runs owned by other tenants. The issue breaks tenant isolation in multi-tenant Trigger.dev deployments.

Critical Impact

Cross-tenant access to runs allows disclosure of environment secrets and tampering with other tenants' background job execution.

Affected Products

  • Trigger.dev versions up to and including 4.7.6
  • Self-hosted Trigger.dev supervisor workload servers
  • Multi-tenant Trigger.dev deployments exposing the workload API to adjacent networks

Discovery Timeline

  • 2026-10-21 - CVE-2026-114085 published to the National Vulnerability Database (NVD)
  • 2026-10-21 - Last updated in NVD database

Technical Details for CVE-2026-114085

Vulnerability Analysis

Trigger.dev is an open-source background job and workflow platform. The supervisor workload server mediates communication between workloads and the control plane, handling run lifecycle operations such as starting attempts, completing runs, and suspending execution.

The vulnerability stems from the supervisor accepting workload requests without validating that the calling workload owns the targeted run. Any caller that possesses a valid runId and snapshotId pair can invoke privileged run-management endpoints against runs belonging to other deployments. The ownership binding between a workload identity and the runs it is permitted to control is absent at the API boundary.

The impact extends beyond operational tampering. The attempts/start endpoint returns resolved environment variables and run JWTs intended for the owning workload. Environment variables commonly contain API keys, database credentials, and third-party service tokens, so disclosure yields material for lateral movement outside the Trigger.dev platform.

Root Cause

The root cause is missing authentication and authorization checks on the supervisor workload API. The server trusts the runId/snapshotId tuple as sufficient addressing information and does not verify that the requesting workload is bound to the deployment that owns the run. This maps to CWE-306: Missing Authentication for Critical Function.

Attack Vector

Exploitation requires adjacent network access to the supervisor workload server and knowledge of a valid run and snapshot identifier pair. An attacker who already runs a workload within the same environment, or who can reach the supervisor from an adjacent network segment, can enumerate or guess identifier pairs and issue direct requests to the workload endpoints. Successful requests return environment variables and JWTs for the targeted run or alter its lifecycle state. See the GitHub Security Advisory GHSA-jc26-22qp-cgqj and the VulnCheck Advisory for Trigger.dev for additional technical context.

Detect Identity Attacks the Moment Authentication Fails

Singularity™ Identity surfaces credential misuse, lateral movement, and privilege escalation in real time, so you can contain the breach before it spreads.

Stop Identity Attacks

Detection Methods for CVE-2026-114085

Indicators of Compromise

  • Supervisor workload API requests to attempts/start, run complete, or run suspend endpoints originating from workloads not associated with the targeted deployment.
  • Unexpected retrieval of environment variables or run JWTs recorded in supervisor logs.
  • Runs transitioning to started, completed, or suspended states without a corresponding scheduled trigger or user action.

Detection Strategies

  • Correlate workload identity against the deployment that owns each runId referenced in supervisor API logs and alert on mismatches.
  • Baseline normal per-tenant request rates to the workload API and flag deviations consistent with enumeration of runId/snapshotId pairs.
  • Review audit logs for run state changes that lack a matching scheduling or user-initiated event.

Monitoring Recommendations

  • Forward supervisor workload API access logs and run lifecycle events to a centralized logging or SIEM platform for cross-tenant correlation.
  • Monitor outbound traffic from workloads for use of credentials that were exposed through the Trigger.dev environment variable store.
  • Track creation of new workloads with unusual network scope or elevated access to the supervisor subnet.

How to Mitigate CVE-2026-114085

Immediate Actions Required

  • Upgrade Trigger.dev to a fixed release above 4.7.6 as published in the GitHub Security Advisory GHSA-jc26-22qp-cgqj.
  • Rotate all secrets and API keys stored as Trigger.dev environment variables that may have been exposed through the workload API.
  • Invalidate outstanding run JWTs issued by affected supervisors and force reissuance after patching.
  • Restrict network access to the supervisor workload server so that only trusted workload subnets can reach it.

Patch Information

The maintainers address the issue in releases after 4.7.6. Review the GitHub Security Advisory GHSA-jc26-22qp-cgqj for the fixed version, applied authentication checks, and upgrade guidance. The fix introduces ownership verification so the supervisor rejects requests from workloads that do not own the referenced run.

Workarounds

  • Segment the supervisor workload server behind strict network policies and allowlist only workloads that must call it.
  • Apply mutual TLS or a service mesh identity layer in front of the supervisor API to bind workload identity to each request.
  • Audit existing deployments for shared network reachability between tenants and isolate workloads into per-tenant namespaces where possible.
bash
# Example Kubernetes NetworkPolicy restricting supervisor access to a trusted workload namespace
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: trigger-supervisor-allowlist
  namespace: trigger
spec:
  podSelector:
    matchLabels:
      app: trigger-supervisor
  policyTypes:
    - Ingress
  ingress:
    - from:
        - namespaceSelector:
            matchLabels:
              trigger-tenant: trusted
      ports:
        - protocol: TCP
          port: 8020

Disclaimer: This content was generated using AI. While we strive for accuracy, please verify critical information with official sources.

Sources: National Vulnerability Database, CISA KEV, Exploit-DB

Experience the Most Advanced Cybersecurity Platform

See how the world’s most intelligent, autonomous cybersecurity platform can protect your organization today and into the future.