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



CVE-2026-73654

CVE-2026-73654: Prototype Pollution in Trigger.dev leading to Cascading Denial of Service

Alon Barad
Alon Barad
Software Engineer

Aug 13, 2026·6 min read·35 visits

Executive Summary (TL;DR)

Unvalidated JSON path validation in the Trigger.dev metadata update endpoint allows authenticated attackers to pollute Object.prototype, crashing Prisma queries and Prometheus metrics client instances, resulting in a system-wide denial of service.

CVE-2026-73654 is a high-severity prototype pollution vulnerability in Trigger.dev. The flaw occurs during the handling of run-metadata updates through the PUT /api/v1/runs/:runId/metadata endpoint. Because user-supplied keys are parsed directly by the @jsonhero/path library without sanitization, an authenticated attacker with low privileges can pollute the global Object.prototype. This causes database queries via Prisma ORM to fail validation and induces unhandled exceptions in the Prometheus metrics client, resulting in a process-wide denial of service.

Vulnerability Overview

CVE-2026-73654 identifies a high-severity prototype pollution vulnerability located in the core orchestration engine of Trigger.dev, an open-source background jobs and AI workflow platform. The flaw resides in the handling of run-metadata updates through the PUT /api/v1/runs/:runId/metadata API endpoint. Under normal operational conditions, this endpoint allows client applications to dynamically assign metadata payloads to execution states.\n\nAt the core of this vulnerability is the ingestion of user-defined JSON path notations by the @jsonhero/path library. The library processes these inputs without validation or sanitization of path segments. Consequently, the endpoint exposes a vector where unauthorized or low-privileged users can supply keys that traverse beyond the boundaries of local scope.\n\nAn attacker who possesses a standard environment API key can exploit this vulnerability to overwrite properties of the shared runtime base prototype. Because the server processes run metadata updates in the same Node.js execution context as other system processes, the resultant pollution affects all active operations. This leads to system-wide degradation, cascading errors in database drivers, and complete platform denial of service.

Root Cause Analysis

The root cause of CVE-2026-73654 is an improperly controlled modification of object prototype attributes, classified under CWE-1321. The vulnerability exists within the metadata operation processing pipeline defined in packages/core/src/v3/runMetadata/operations.ts. The implementation accepts client-supplied keys to perform fine-grained object manipulation within a run's state metadata.\n\nSpecifically, the application initializes a JSONHeroPath instance with a user-supplied key and invokes the .set() method. The target object is intended to be a simple dictionary representing execution metadata. However, the @jsonhero/path library resolves standard JSON path structures, including keys containing parent and root references, without checking for forbidden property names.\n\nWhen a client specifies a path containing the __proto__ property, the resolver navigates the object hierarchy and references the underlying Object.prototype. The subsequent assignment action writes the specified value directly onto this global prototype object. In Node.js runtimes, all plain JavaScript objects inherit from Object.prototype, meaning any attribute defined here immediately populates all subsequently instantiated objects.

Code Analysis

The vulnerable implementation in packages/core/src/v3/runMetadata/operations.ts processed metadata operations by directly instantiating the path parser on client-controlled keys. The code lacked any verification step prior to invoking the mutation logic on the target metadata structure.\n\ntypescript\n// Vulnerable Code Path\n// User-controlled key was passed directly to the JSONHeroPath constructor\nnew JSONHeroPath(operation.key).set(newMetadata, value);\n\n\nThe remediation applied in commit 6997aeb05e27d2db47f9eda01fdc8a17c81a1ae0 addresses this by implementing a validation guard before any mutation is attempted. The application now iterates over incoming operations and evaluates each operation key using isSafeMetadataKey to block unsafe paths.\n\ntypescript\n// Patched Code Path in packages/core/src/v3/runMetadata/operations.ts\nfor (const operation of Array.isArray(operations) ? operations : [operations]) {\n // Prevent unsafe JSON paths and direct __proto__ assignments from changing Object.prototype.\n if (operation.type !== "update" && !isSafeMetadataKey(operation.key)) {\n unappliedOperations.push(operation);\n continue;\n }\n\n\nThe helper function isSafeMetadataKey in packages/core/src/v3/schemas/common.ts implements a multi-tiered defense against path-based pollution. It blocks both direct manipulation of __proto__ and any JSON path that splits into segments matching forbidden prototype attributes.\n\ntypescript\n// Validation logic in packages/core/src/v3/schemas/common.ts\nconst DANGEROUS_METADATA_KEY_SEGMENTS = new Set(["__proto__", "constructor", "prototype"]);\n\nexport function isSafeMetadataKey(key: string): boolean {\n if (!key.startsWith("$.")) {\n return key !== "__proto__";\n }\n\n return !key.split(/[.[\]'\u0022]+/).some((segment) => DANGEROUS_METADATA_KEY_SEGMENTS.has(segment));\n}\n\n\nThis fix is complete because it addresses all potential path traversal syntaxes that @jsonhero/path parses, including bracket notations and dot-notations. Additionally, it hardens the flattenAttributes utility, preventing telemetry ingestion mechanisms from causing similar pollution.

Exploitation Methodology

Exploitation of CVE-2026-73654 requires low privileges, specifically a standard workspace environment API key. The attacker must first obtain a valid run identifier associated with their workspace environment. This requirement makes the vulnerability accessible to compromised internal accounts or low-privileged workspace members.\n\nTo execute the attack, the adversary structures a PUT request targeting the /api/v1/runs/:runId/metadata endpoint. The body of the request contains an operations array designed to inject a key value that accesses the prototype. The JSON path $.__proto__.corruptedProperty is used as the target key.\n\njson\n{\n "operations": [\n {\n "type": "set",\n "key": "$.__proto__.corruptedProperty",\n "value": "trigger-denial-of-service"\n }\n ]\n}\n\n\nUpon receiving this request, the server executes the set operation, which traverses and updates Object.prototype.corruptedProperty. Once the pollution is achieved, the shared process immediately begins inheriting this property across all object instances. The diagram below illustrates the attack flow and subsequent process failures.\n\nmermaid\ngraph LR\n Attacker[\"Attacker (Low Privilege)\"] -->|HTTP PUT with polluted key| Endpoint[\"/api/v1/runs/:runId/metadata\"]\n Endpoint -->|Resolves $.\u005f\u005fproto\u005f\u005f| Engine[\"JSONHeroPath.set()\"]\n Engine -->|Modifies| Prototype[\"Global Object.prototype\"]\n Prototype -->|Inherited by| Prisma[\"Prisma ORM Builder\"]\n Prototype -->|Inherited by| PromClient[\"prom-client Metrics\"]\n Prisma -->|Validation Failure| DBError[\"Database Query Failure\"]\n PromClient -->|Unhandled Exception| Crash[\"Process Crash (DoS)\"]\n

Impact Assessment

The security impact of CVE-2026-73654 is evaluated as High, with a CVSS v3.1 score of 8.5. The vulnerability allows an authenticated attacker to execute a highly effective Denial of Service (DoS) attack that crosses tenant boundaries. This cross-tenant behavior justifies the Scope (S) parameter being classified as Changed.\n\nBecause Trigger.dev utilizes a shared webapp process architecture for multiple workspaces and tenants, the prototype pollution is not isolated to the attacker's workspace. Every tenant whose requests are handled by the polluted webapp node experiences database access failures due to Prisma ORM query builder crashes. Prisma identifies the polluted key as an invalid query parameter and throws immediate parsing errors.\n\nFurthermore, the Prometheus instrumentation client (prom-client) regularly iterates over global metrics configurations. When it processes properties from the polluted prototype, it encounters unexpected string values where numeric structures or labels are expected, leading to unhandled runtime exceptions. This crashes the main thread of the webapp container, disrupting background workers, authentication checks, and active workflows globally.

Remediation and Mitigation

The primary remediation path for CVE-2026-73654 is to upgrade the Trigger.dev dependency suite and self-hosted instances to version 4.5.6 or later. This release integrates the proper input validation schemas and helper functions to neutralize prototype pollution payloads before they reach the path resolver.\n\nIf an immediate upgrade is not feasible, organizations running self-hosted instances should apply web application firewall (WAF) filtering. The WAF rules must inspect the payload of HTTP PUT requests targeted at paths ending in /metadata. Specifically, the rules must identify and block payloads containing the key words __proto__, constructor, or prototype when formatted inside JSON fields.\n\nAdditionally, developers are advised to audit custom metadata parsing logic to ensure that generic input parsing utilities do not trust unsanitized JSON path inputs. Implementing strict Zod schemas with refinement checks, as demonstrated in the patch, is the recommended security pattern for handling dynamic nested configurations in TypeScript.

Technical Appendix

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

Affected Systems

Trigger.dev Self-Hosted PlatformsTrigger.dev Cloud Worker Nodes

Affected Versions Detail

Product
Affected Versions
Fixed Version
trigger.dev
triggerdotdev
>= 3.3.8, < 4.5.64.5.6
AttributeDetail
CWE IDCWE-1321
Attack VectorNetwork (AV:N)
Attack ComplexityLow (AC:L)
Privileges RequiredLow (PR:L)
ScopeChanged (S:C)
Integrity ImpactLow (I:L)
Availability ImpactHigh (A:H)
CVSS Score8.5
Exploit StatusPoC (Proof of Concept)
CISA KEV StatusNot Listed

MITRE ATT&CK Mapping

T1059Command and Scripting Interpreter
Execution
CWE-1321
Improperly Controlled Modification of Object Prototype Attributes

Improperly Controlled Modification of Object Prototype Attributes ('Prototype Pollution')

Known Exploits & Detection

GitHub Security AdvisoryVulnerability description and proof of concept references in the official repository advisory.

Vulnerability Timeline

Security patch committed to the trigger.dev repository
2026-07-21
Trigger.dev release v4.5.6 tagged and pushed to registry
2026-07-21
Vulnerability formally assigned CVE-2026-73654 and published
2026-08-13

References & Sources

  • [1]GitHub Security Advisory GHSA-p28v-f755-9qrg
  • [2]Fix Commit 6997aeb05e27d2db47f9eda01fdc8a17c81a1ae0
  • [3]Pull Request #4316
  • [4]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

•about 1 hour ago•CVE-2026-91112
6.8

CVE-2026-91112: Privilege Escalation via CMS_ACCESS_SecurityAdmin in Silverstripe Framework

Silverstripe Framework prior to version 6.2.13 contains an improper privilege management vulnerability (CWE-269) within the Group authorization and validation logic. A delegated administrator possessing the CMS_ACCESS_SecurityAdmin permission, but lacking full ADMIN privileges, can edit or reparent groups that acquire administrative capabilities indirectly via permission roles or ancestor inheritance. By adding their own account to such a group or moving a controlled group underneath a role-privileged parent, the user escalates to full administrative access across the CMS.

Amit Schendel
Amit Schendel
1 views•9 min read
•about 2 hours ago•CVE-2026-91113
4.3

CVE-2026-91113: Missing Authorization and Arbitrary Record Type Conversion in Silverstripe Framework GridFieldDetailForm

A missing authorization and type validation vulnerability in Silverstripe Framework prior to version 6.2.13 allows authenticated CMS users to convert database records into arbitrary DataObject classes via user-controlled ClassName parameters in GridField detail forms.

Alon Barad
Alon Barad
4 views•9 min read
•about 3 hours ago•CVE-2026-91115
8.8

CVE-2026-91115: Remote Code Execution in Silverstripe Framework via i18nTextCollectorTask

CVE-2026-91115 (GHSA-c94f-87xg-65wf) is an unsafe reflection vulnerability in the Silverstripe Framework affecting versions 6.0.0 prior to 6.2.13. The built-in development task i18nTextCollectorTask passes the user-supplied 'writer' parameter directly to Silverstripe's dependency injection container (Injector::inst()->get()) without verifying that the requested class implements the expected Writer interface. Because the dependency injector supports instantiating arbitrary classes with attacker-supplied constructor arguments, and because nested task URLs bypassed interactive confirmation middleware, an attacker can achieve remote code execution via unauthenticated requests on development instances or via Cross-Site Request Forgery (CSRF) against authenticated administrators on production instances.

Amit Schendel
Amit Schendel
5 views•8 min read
•about 4 hours ago•CVE-2026-129237
5.4

CVE-2026-129237: Partial Path Traversal (Zip Slip) in qbee-agent Tar Extractor

CVE-2026-129237 is a partial path traversal (Zip Slip) vulnerability in qbee-agent, the device agent for the qbee.io IoT device management platform. Prior to version 2026.41, the tar archive extraction routine in app/utils/tar.go used strings.HasPrefix without enforcing a directory separator boundary. When the Docker Compose bundle configuration has UseContext enabled, an authenticated user with delegated configuration or file management privileges can supply a crafted tar archive containing sibling-prefix traversal sequences, allowing directory creation and file writes into adjacent sibling directories outside the intended extraction root.

Alon Barad
Alon Barad
4 views•11 min read
•about 5 hours ago•CVE-2026-128118
7.5

CVE-2026-128118: Server-Only Module Guard Bypass and Secret Exposure in SvelteKit

CVE-2026-128118 (GHSA-m9j8-jcmv-hp69) is an information disclosure vulnerability affecting the SvelteKit framework (@sveltejs/kit) from version 3.0.0 through 3.1.0. A design flaw in the build-time Vite module guard plugin (plugin_guard) failed to register src/params.js as a client entry point and implemented a fail-open validation model. Consequently, server-only modules and private environment variables imported directly or dynamically within parameter matchers were compiled into publicly accessible client-side JavaScript bundles without triggering a build error.

Amit Schendel
Amit Schendel
4 views•10 min read
•about 6 hours ago•CVE-2026-128071
6.5

CVE-2026-128071: Route-Rule Authorization Bypass via Encoded Slashes in Nuxt

CVE-2026-128071 is a route-rule authorization bypass and security policy circumvention vulnerability in the Nuxt web framework, affecting `nuxt`, `@nuxt/nitro-server`, and `@nuxt/vite-server` prior to version 4.6.4. Serving as an incomplete fix for GHSA-6gq8-jgmh-3ffp, the flaw arises from an interpretation conflict between Nuxt's route-rule matching logic and Vue Router's catch-all route parameter decoding. When processing an incoming HTTP request containing percent-encoded forward slashes (`%2F` or `%2f`), the route-rule evaluation engine preserves the encoded sequence as a single path segment, failing to match prefix-based rules such as `/admin/**`. However, when the request is subsequently dispatched to a catch-all page route (`app/pages/[...slug].vue`) or a multi-segment parameter handler, the parameters are URL-decoded into literal slash delimiters. This discrepancy allows unauthenticated remote attackers to bypass route-level redirects, authentication middleware (`appMiddleware`), security headers, proxy configurations, and rendering constraints (`ssr: false`, `noScripts`), while the catch-all page resolves and renders the protected resource.

Amit Schendel
Amit Schendel
5 views•11 min read