Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
ReconObtain valid environment API key
-
DeliverySend crafted PUT /api/v1/runs/:runId/metadata request with __proto__ path key
-
ExploitJSONHeroPath.set() writes to Object.prototype
-
InstallPolluted properties propagate across shared Node.js process
-
C2Prisma ORM queries malform and Prometheus labels corrupt
-
ExecuteWorker authentication failures eject other tenants' workers
-
ImpactProcess-wide denial of service until restart
Vulnerability Assessment
| Weakness |
CWE
ASVS 5.0
V3 - Web Frontend Security Prototype pollution prevention
MITRE ATT&CK
2 techniques across 2 tactics: Execution, Initial Access The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up. |
| Exploitation Conditions | Exploitation requires possession of a valid Trigger.dev environment API key at the low-privilege level (CVSS PR:L confirmed). Any key issued to a legitimate tenant suffices - no administrative, project-owner, or elevated role is needed. The vulnerable endpoint (PUT /api/v1/runs/:runId/metadata) is a standard part of the platform's run management API and requires no non-default feature flag or special configuration to be present. Unauthenticated exploitation is not possible. Cross-tenant impact is bounded by the shared webapp process architecture: self-hosted deployments with per-tenant process isolation would limit blast radius to the attacker's own process, though availability impact would still apply. The run ID used in the request path does not need to belong to the attacker - any run ID accepted by the endpoint is sufficient to trigger the prototype pollution. |
| Impact | The CVSS 3.1 score of 8.5 (AV:N/AC:L/PR:L/UI:N/S:C/C:N/I:L/A:H) accurately reflects the real-world threat profile. The scope-change metric (S:C) is the most operationally significant signal: a single authenticated tenant can disrupt availability and integrity for every other tenant sharing the webapp process, transforming a low-privilege credential into a cross-tenant weapon. The PR:L rating is correct - any holder of a standard environment API key qualifies, meaning the effective attacker pool includes all registered users of a shared deployment. Attack complexity is genuinely low: no race conditions, no special sequencing, and the JSONHeroPath vector is well-understood in the Node.js security community. No EPSS data was provided, and this CVE does not appear in the CISA KEV catalog, so active exploitation remains unconfirmed; however, the mechanically simple attack chain and publicly available PR diff supply enough information for a competent researcher to reproduce the issue without a dedicated proof-of-concept. The absence of confidentiality impact (C:N) is plausible given the current description, but prototype pollution can sometimes be chained to read injected properties - this secondary risk is not confirmed by available data and should not be assumed. Self-hosted single-tenant deployments face a lower blast radius (no cross-tenant scope change) but are still vulnerable to self-inflicted availability loss. |
| Exploit ScenarioDerived | An attacker holding any valid Trigger.dev environment API key sends a PUT request to /api/v1/runs/<any-runId>/metadata with a metadata operation whose key is set to __proto__.someProperty and value to an attacker-chosen primitive. The shared webapp process applies the mutation via JSONHeroPath.set(), writing to Object.prototype. Immediately, all objects instantiated in the process - including Prisma query builder instances and Prometheus label objects - inherit the injected property, causing malformed database queries and authentication failures that affect every other tenant until the process is restarted. The PR diff and CVE description together provide sufficient detail for an experienced researcher to construct this payload without an explicit proof-of-concept. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Aug 13, 2026
Prototype pollution in Trigger.dev's run metadata API (versions 3.3.8 through 4.5.5) lets any authenticated tenant corrupt the shared Node.js webapp process's Object.prototype by supplying crafted path keys to the PUT /api/v1/runs/:runId/metadata endpoint. The root cause is the unsanitized use of attacker-supplied operation.key values passed directly to JSONHeroPath.set() in packages/core/src/v3/runMetadata/operations.ts without filtering __proto__, constructor, or prototype segments. A single exploiting tenant can corrupt Prisma ORM queries, poison Prometheus metric labels, break other tenants' worker authentication, and cause a process-wide denial of service - making this a multi-tenant isolation failure with scope-changed impact. No public exploit code or CISA KEV listing has been identified at time of analysis.
RemediationAI
Upgrade to Trigger.dev version 4.5.6 or later; this is the vendor-released patch confirmed by GitHub release tag v4.5.6 and security advisory GHSA-p28v-f755-9qrg. The fix, implemented in PR #4316 (https://github.com/triggerdotdev/trigger.dev/pull/4316) and commit 6997aeb (https://github.com/triggerdotdev/trigger.dev/commit/6997aeb05e27d2db47f9eda01fdc8a17c81a1ae0), validates and rejects dangerous prototype path segments in JSONHeroPath keys before mutation while preserving legitimate uses of 'constructor' and 'prototype' as field names. For self-hosted operators who cannot immediately upgrade, a compensating control is to deploy a reverse proxy or WAF rule rejecting PUT /api/v1/runs/*/metadata request bodies whose JSON keys contain the strings __proto__, constructor, or prototype - note this may generate false positives for payloads that use those strings as intentional data fields. Additionally, auditing and minimizing the issuance of environment API keys reduces the pool of potential exploiters but does not address the root vulnerability. Process restart clears a polluted prototype state, but does not prevent re-exploitation without the patch.
Affected VersionsENISA
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 2 packages in npm, euvd
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
Trigger.dev is a managed AI agent and workflow platform built on Node.js. The affected code path in packages/core/src/v3/runMetadata/operations.ts uses the JSONHeroPath library, which resolves dot-notation key paths to traverse and mutate JSON objects. When operation.key contains prototype-polluting segments such as __proto__, constructor, or prototype, JSONHeroPath.set() walks up the JavaScript prototype chain and writes attacker-controlled values directly onto Object.prototype - the root prototype inherited by every plain object in the Node.js process. Because the webapp runs as a single shared process serving multiple tenants, a polluted Object.prototype immediately contaminates all subsequent property lookups: Prisma ORM query builders construct malformed queries, Prometheus label objects inherit injected properties, and authentication checks that rely on object property presence return unexpected results. CWE-1321 (Improperly Controlled Modification of Object Prototype Attributes) is the precise root cause class. CPE cpe:2.3:a:triggerdotdev:trigger.dev:*:*:*:*:*:*:*:* covers all versions from 3.3.8 up to and including 4.5.5.
Know when Prototype Pollution gets its next vulnerability
- Watch products and get an email when something new is published
- Check this CVE against your own stack and servers
- Exploit and PoC references, threat intelligence from 22 sources
No credit card · 7-day full trial
Severity by source
AV:N/AC:L/PR:L/UI:N/S:C/C:N/I:L/A:H
Network API endpoint exploitable with any tenant API key (PR:L, AC:L); scope change reflects cross-tenant process pollution; high availability loss from process-wide DoS; no confidentiality exfiltration confirmed.
Primary rating from Vendor (GitHub_M).
CVSS VectorVendor: GitHub_M
Lifecycle Timeline
2DescriptionCVE.org
Trigger.dev is a platform for building and deploying fully managed AI agents and workflows. From 3.3.8 until 4.5.6, the PUT /api/v1/runs/:runId/metadata endpoint passes attacker-controlled operation.key values to new JSONHeroPath(operation.key).set(newMetadata, value) in packages/core/src/v3/runMetadata/operations.ts without rejecting dangerous constructor and prototype path segments. A caller with a normal environment API key can pollute Object.prototype in the shared webapp process, corrupting Prisma queries and Prometheus labels, breaking other tenants' worker authentication, and causing a process-wide denial of service. This issue is fixed in version 4.5.6.
Blast Radius
ecosystem impact- 3 npm packages depend on @trigger.dev/core (3 direct, 0 indirect)
Ecosystem-wide dependent count for version 3.3.8.
Latest POC
1 public PoC link from github
Sign in to open the public PoC links collected for this CVE.
Executive ViewAI
Trigger.dev versions 3.3.8-4.5.5 contain a critical vulnerability allowing any authenticated user to corrupt the shared application process, affecting all customers on these versions. While no public exploit has been identified at time of analysis, this multi-tenant isolation failure enables a single malicious tenant to sabotage other tenants' applications, disrupt service availability, and manipulate data integrity-representing immediate risk to business continuity and customer trust for organizations using Trigger.dev in a multi-tenant environment.
No vendor-released patch identified at time of analysis. Implement interim mitigations: request-level filtering on the metadata API endpoint to reject any payload containing '__proto__', 'constructor', or 'prototype' in operation.key values; enforce rate limiting on the metadata API to reduce attack surface; deploy process isolation between tenant workloads if architecture permits; enable detailed request logging and alerting for suspicious metadata modifications; and establish a rollback plan to downgrade Trigger.dev to an unaffected version if exploitation is detected.
Threat Intelligence Overview
How this decision was reached
The engine reads each signal below and applies a fixed list of rules from top to bottom. The first rule that matches sets the recommended action – like a statement, every line is shown.
What every action level means
SSVC AssessmentENISA
Priority Score
Attack Technique
Denial of Service attacks render applications or systems unavailable by overwhelming resources or triggering failure conditions.
More in Prototype Pollution
View allPrototype pollution in Adobe Acrobat Reader versions 24.001.30356, 26.001.21367 and earlier enables arbitrary code execu
All versions of package dojo are vulnerable to Prototype Pollution via the setObject function. Rated critical severity (
Prototype pollution in the farinspace Partners WordPress plugin (versions up to and including 0.2.0) enables remote unau
The package handlebars before 4.7.7 are vulnerable to Prototype Pollution when selecting certain compiling options to co
This affects the package ini before 1.3.6. Rated critical severity (CVSS 9.8), this vulnerability is remotely exploitabl
Prototype pollution vulnerability in 'deephas' versions 1.0.0 through 1.0.5 allows attacker to cause a denial of service
A Prototype Pollution issue in Cronvel Tree-kit v.0.7.4 and before allows a remote attacker to execute arbitrary code vi
A Prototype Pollution issue in Aliconnect /sdk v.0.0.6 allows an attacker to execute arbitrary code via the aim function
All versions of the package safe-eval are vulnerable to Prototype Pollution via the safeEval function, due to improper s
This affects the package vm2 before 3.9.4 via a Prototype Pollution attack vector, which can lead to execution of arbitr
Prototype Pollution in chargeover redoc v2.0.9-rc.69 allows attackers to execute arbitrary code or cause a Denial of Ser
alizeait unflatto <= 1.0.2 was discovered to contain a prototype pollution via the method exports.unflatto at /dist/inde
EUVD-2026-58358
GHSA-p28v-f755-9qrg
NVD
CVE.org
EPSS
Vulnrichment
VulDB
Exploit-DB