CVEReports
CVEReports

Automated vulnerability intelligence platform. Comprehensive reports for high-severity CVEs generated by AI.

Product

  • Home
  • Sitemap
  • RSS Feed

Company

  • About
  • Contact
  • Privacy Policy
  • Terms of Service

© 2026 CVEReports. All rights reserved.

Made with love by Amit Schendel & Alon Barad



GHSA-4672-HWV6-GQ62

GHSA-4672-HWV6-GQ62: Cross-environment deployment cancellation in Trigger.dev

Alon Barad
Alon Barad
Software Engineer

Oct 3, 2026·6 min read·10 visits

Executive Summary (TL;DR)

An asymmetric authorization gap in Trigger.dev allows low-privilege development keys to cancel high-privilege production deployments due to a missing environment-level scoping filter on write actions.

A logical authorization bypass vulnerability exists in Trigger.dev versions prior to 4.5.6. This flaw allows an authenticated client with a low-trust environment API key, such as development or staging, to cancel active worker deployments in a higher-trust environment like production within the same project. The vulnerability occurs because write operations on deployments were scoped solely by project identifier instead of environment identifier.

Vulnerability Overview

Trigger.dev utilizes a multi-environment architecture to segregate execution environments, dividing them into distinct tiers such as development, staging, and production. Each individual environment is assigned a unique, high-entropy API key that establishes a security boundary. This model assumes that development keys are lower trust compared to production keys.

This architecture is designed to prevent cross-environment tampering. However, a logical flaw was identified where the backend service did not enforce strict environment isolation during the deployment cancellation process. As a result, an attacker possessing an API key for a low-trust environment could successfully cancel active deployments in a production environment.

The vulnerability represents a breakdown in horizontal privilege escalation protection. It is cataloged as a logical authorization bypass. The root cause lies in the application of project-level scopes rather than environment-level scopes on write operations. This exposes active deployments to unauthorized cross-environment interference.

Root Cause Analysis

In the relational database schema of Trigger.dev, a single project can contain multiple environments. Each deployment is associated with both a specific environment ID and a general project ID. To enforce correct access controls, operations must authenticate against both parameters to guarantee the request originates from the matching environment context.

The vulnerability occurs because the getDeployment database query inside the deployment management service was implemented using only the projectId and the deployment friendlyId. While this query successfully restricted operations to the correct tenant, it completely bypassed the finer-grained environment check. Consequently, any authenticated key belonging to any environment in that project could retrieve and modify any deployment record.

This issue presents a stark contrast to the corresponding GET endpoint which retrieves deployment details. The read endpoint correctly verifies that the requested deployment matches the environmentId of the caller. This asymmetry allowed an API key to write and modify a resource that it was completely unauthorized to view.

Code Analysis

The vulnerable implementation of the deployment service relied on a helper function that lacked the environment parameter. In apps/webapp/app/v3/services/deployment.server.ts, the database query was defined to filter only on the project identifier and the deployment identifier:

// Vulnerable method signature and database query
private getDeployment(projectId: string, friendlyId: string) {
  return this._prisma.workerDeployment.findFirst({
    where: {
      friendlyId,
      projectId, // Only scopes query to the parent project
    },
  });
}

This implementation was refactored in version 4.5.6 to accept and enforce the environment ID. The patched code introduces the environmentId parameter into the helper function, modifying the Prisma selector to restrict the query dynamically to the exact authenticated environment:

// Patched method signature enforcing environment isolation
private getDeployment(environmentId: string, friendlyId: string) {
  return fromPromise(
    this._prisma.workerDeployment.findFirst({
      where: {
        friendlyId,
        environmentId, // Restricts lookup to the authenticated environment
      },
      select: {
        status: true,
        id: true,
      }
    })
  );
}

The patch completely mitigates the logical bypass by shifting the authorization anchor from project level to environment level. Security teams have verified that this fix prevents cross-environment cancellation requests. Additionally, related routes such as credential generation endpoints were updated with identical environment constraints to ensure uniform enforcement.

Exploitation Methodology

An exploitation scenario requires the attacker to possess a valid API key for a low-trust environment within the target project. The attacker must also identify the target deployment identifier, which is typically formatted as a structured string. Because the read endpoint is secure, this identifier must be obtained via secondary channels such as build logs, monitoring tools, or administrative portals.

To perform the attack, the adversary initiates a POST request directly to the deployment cancellation endpoint of the Trigger.dev API. The request is authorized using the developer API key, which passes the project-level validation check:

POST /api/v1/deployments/deployment_pocvictim/cancel HTTP/1.1
Host: api.trigger.dev
Authorization: Bearer tr_dev_examplekey123
Content-Type: application/json

The backend processes this request, retrieves the target deployment because it shares the same project ID, and transitions its database state to the canceled status. The server returns a success response, confirming the modification. If the attacker attempts this action on a deployment belonging to a completely different project, the request fails with a 404 status.

Impact Assessment

The vulnerability has been assigned a CVSS score of 5.4, indicating medium severity. The primary security impact is focused on availability and integrity, with no impact on confidentiality. Because read requests on deployments are correctly validated, attackers cannot view environment variables, secret tokens, or private build logs using this vulnerability.

The degradation of integrity lies in the unauthorized modification of deployment states from pending or active status to canceled. This allows malicious actors to prematurely terminate critical builds. The availability threat is significant for organizations relying on automated continuous deployment systems, as an attacker can systematically block all update paths.

The scope of the vulnerability remains unchanged because it does not allow cross-tenant operations. Attackers are restricted to environments within projects where they already hold valid API keys. The primary risk is insider threats or compromised development pipelines where low-trust keys are exposed to developers or CI scripts.

Remediation Guidance

The primary remediation strategy is to upgrade all Trigger.dev instances to version 4.5.6 or later. This release updates the core service files to enforce strict environment isolation across all write pathways. Administrators can verify dependency configurations in package.json to ensure the core libraries match the patched version:

{
  "dependencies": {
    "@trigger.dev/core": "^4.5.6"
  }
}

For self-hosted instances, administrative teams must redeploy the platform container instances using the updated images from the official registry. It is recommended to rotate all existing development and preview environment keys to invalidate any credentials that might have been compromised prior to the patch.

In addition to applying the patch, organizations should implement the least privilege principle by limiting the distribution of environment keys. Restricting API key visibility within CI/CD configuration panels reduces the risk of accidental exposure. Implementing monitoring on the cancellation endpoints can also alert security teams to unexpected cross-environment access patterns.

Official Patches

Trigger.devPull Request implementing environmentId constraints

Fix Analysis (1)

Technical Appendix

CVSS Score
5.4/ 10
CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:N/I:L/A:L

Affected Systems

Trigger.dev platform self-hosted instances@trigger.dev/core npm packagetrigger.dev npm ecosystem

Affected Versions Detail

Product
Affected Versions
Fixed Version
trigger.dev
Trigger.dev
<= 4.5.54.5.6
AttributeDetail
CWE IDCWE-639
Attack VectorNetwork
CVSS5.4
ImpactIntegrity and Availability (Partial)
Exploit StatusProof-of-Concept (PoC) available
KEV StatusNot Listed

MITRE ATT&CK Mapping

T1059Command and Scripting Interpreter
Execution
T1548Abuse Elevation Control Mechanism
Privilege Escalation
CWE-639
Bypass of Authorization Using User-Controlled Key

The system fails to prevent a user from accessing or modifying resources of another environment by using user-controlled parameters inside a project scope.

Known Exploits & Detection

GitHub AdvisoryAnalysis of cross-environment deployment cancel vulnerability

References & Sources

  • [1]GitHub Security Advisory GHSA-4672-HWV6-GQ62
  • [2]Trigger.dev Release v4.5.6

Attack Flow Diagram

Press enter or space to select a node. You can then use the arrow keys to move the node around. Press delete to remove it and escape to cancel.
Press enter or space to select an edge. You can then press delete to remove it or escape to cancel.

More Reports

•28 minutes ago•CVE-2026-69241
5.4

CVE-2026-69241: Stored Cross-Site Scripting via Unsanitized SVG Upload in Filament Curator

Filament Curator, a media picker plugin for Filament panels in Laravel applications, contains a Stored Cross-Site Scripting (XSS) vulnerability in versions prior to 3.7.9, 4.1.2, and 5.1.2. The application accepts image/svg+xml uploads by default and stores them on disk without stripping executable XML markup. When a panel user opens an uploaded SVG via the View action, the file renders as a top-level document in the browser, executing embedded JavaScript within the origin of the Filament application.

Alon Barad
Alon Barad
1 views•9 min read
•about 3 hours ago•CVE-2026-63182
8.1

CVE-2026-63182: XML Signature Wrapping Authentication Bypass in LightSAML

CVE-2026-63182 is a high-severity XML Signature Wrapping (XSW) vulnerability in LightSAML (litesaml/lightsaml), a PHP library implementing SAML 2.0 data models and cryptographic verification. An architectural discrepancy between how LightSAML deserializes direct child assertions and how the underlying robrichards/xmlseclibs library resolves XML document fragment identifiers allows an attacker with a valid signed assertion to forge arbitrary SAML identity claims and bypass authentication.

Alon Barad
Alon Barad
4 views•11 min read
•about 4 hours ago•CVE-2026-119351
6.3

CVE-2026-119351: Cross-Context Cache Leak via Delayed Inner Stream Metadata in Next.js

A race condition and improper synchronization vulnerability (CWE-362) exists in Next.js versions 16.2.0 prior to 16.4.5 when Cache Components ('use cache' directive) are enabled. When an outer cached function calls a nested cached function that reads dynamic root parameters via 'next/root-params' and returns an object containing pending promises, React Flight can resolve and deliver the ready portion of the payload before the inner cache finishes publishing its root parameter dependencies. Consequently, the outer cache entry finalizes and persists under a cache key that omits the root parameter dependencies, causing the first written cache entry to be served across requests with different root parameter values and bypassing nested cache invalidation rules.

Amit Schendel
Amit Schendel
7 views•10 min read
•about 5 hours ago•CVE-2026-68934
8.7

CVE-2026-68934: OS Command Injection in code-review-mcp-server via Unsafe Shell Execution

A remote OS command injection vulnerability (CWE-78) exists in code-review-mcp-server prior to version 1.5.3. The application passes caller-controlled tool parameters directly into Node.js child_process.execSync() calls without proper neutralization. An attacker or compromised LLM agent invoking tools such as getLocalGitDiff, codeReview, createPR, or getPRTemplate can inject arbitrary shell commands that execute with the privileges of the MCP server host process.

Alon Barad
Alon Barad
7 views•11 min read
•about 6 hours ago•CVE-2026-86046
7.1

CVE-2026-86046: Arbitrary File Write via Path Traversal in termux-sync Restore Workflow

A path traversal vulnerability (CWE-22) in termux-sync prior to version 1.2.4 allows an attacker to overwrite arbitrary files within the Termux environment during the backup restoration process. The flaw stems from the application trusting attacker-controlled extraction paths defined in the backup's manifest.json file, failing to validate archive members against directory traversal sequences during tar extraction, and using unsanitized backup names when constructing temporary directories. If a user restores a malicious backup archive from local storage, shared folders, GitHub, or Google Drive, an attacker can overwrite sensitive configuration files such as shell startup scripts or local binaries, resulting in arbitrary code execution under the privileges of the Termux user.

Amit Schendel
Amit Schendel
6 views•11 min read
•about 7 hours ago•CVE-2026-129296
6.5

CVE-2026-129296: Path Traversal in SpamScope mail-parser Attachment Extraction

SpamScope mail-parser versions 3.8.0 prior to 4.6.0 contain a path traversal vulnerability (CWE-22) within the write_attachments() and write_sample() functions. The library passes untrusted attachment filenames directly into os.path.join() without stripping directory components, validating path containment, or verifying symbolic links. An attacker can send a crafted email containing relative path traversal sequences or absolute filesystem paths in the Content-Disposition header to write or overwrite arbitrary files accessible to the parsing process.

Amit Schendel
Amit Schendel
4 views•9 min read