Oct 2, 2026·5 min read·14 visits
Authenticated attackers can execute tasks inside other tenants' environments by specifying a foreign environmentId during task replay, bypassing tenant isolation.
A critical Broken Object Level Authorization (BOLA) vulnerability was identified in Trigger.dev before version v4.5.2. An authenticated attacker could trigger a run replay and supply an arbitrary target environmentId belonging to a completely different tenant. Because the server failed to validate whether the target environment belonged to the same project or organization as the source run, it would execute the task within the victim's environment, resulting in unauthorized cross-tenant write operations and remote task execution.
Trigger.dev is an open-source background jobs framework designed to facilitate complex task orchestration and scheduling. The platform exposes various API endpoints to trigger, monitor, and replay task executions. Security assessment of the task replay workflow revealed a critical Broken Object Level Authorization (BOLA) vulnerability, tracked as GHSA-QXPP-QJG8-X4JV.
This vulnerability allows an authenticated attacker to inject and execute arbitrary tasks in a victim's execution environment. The attack is executed by manipulating the target environment identifier during a task replay request. Because the backend does not validate organization or project boundaries when resolving the target environment, cross-tenant execution is achieved.
The vulnerability affects all self-hosted and cloud deployments of Trigger.dev prior to version v4.5.2. This vulnerability has been remediated in the official v4.5.2 security release.
The root cause of GHSA-QXPP-QJG8-X4JV lies in the logical implementation of the task run replay service, specifically within the ReplayTaskRunService component. In Trigger.dev, task runs are associated with runtime environments which belong to projects and organizations. When a user requests a replay of a completed task, they can optionally specify override options including a new target environment identifier via the environmentId parameter.
The service handled this override by querying the database for the provided environment ID using the internal lookup function findEnvironmentById. This lookup did not apply any multi-tenancy constraints or check whether the target environment belonged to the same project or organization as the original task run.
Because the lookup operated on a global database scope, any valid environment ID could be resolved. Consequently, when the service proceeded to queue and schedule the replayed task, it initiated execution context within the retrieved target environment, even if that environment belonged to an entirely different customer tenant.
To understand the precise vulnerability and its remediation, analyze the difference in apps/webapp/app/v3/services/replayTaskRun.server.ts before and after the security patch. In the vulnerable version, the service class accepted the input and immediately resolved the target environment.
// Pre-patch implementation
export class ReplayTaskRunService extends BaseService {
public async call(existingTaskRun: TaskRun, overrideOptions: OverrideOptions = {}) {
const authenticatedEnvironment = await findEnvironmentById(
overrideOptions.environmentId ?? existingTaskRun.runtimeEnvironmentId
);
// ... execution continues without verifying project tenancy
}
}The security patch introduced in commit 34b1a181c2a1d33a53ebab88f84b05f81fea4254 introduces a strict boundary check. If an override environment ID is supplied and differs from the source environment, the server retrieves both records and compares their respective project identifiers.
// Patched implementation
export class ReplayTaskRunService extends BaseService {
public async call(existingTaskRun: TaskRun, overrideOptions: OverrideOptions = {}) {
if (
overrideOptions.environmentId &&
overrideOptions.environmentId !== existingTaskRun.runtimeEnvironmentId
) {
const [overrideEnvironment, sourceEnvironment] = await Promise.all([
this._prisma.runtimeEnvironment.findFirst({
where: { id: overrideOptions.environmentId },
select: { projectId: true },
}),
this._prisma.runtimeEnvironment.findFirst({
where: { id: existingTaskRun.runtimeEnvironmentId },
select: { projectId: true },
}),
]);
if (
!overrideEnvironment ||
!sourceEnvironment ||
overrideEnvironment.projectId !== sourceEnvironment.projectId
) {
logger.warn("Refusing to replay a run into an environment outside its project", {
taskRunId: existingTaskRun.id,
sourceEnvironmentId: existingTaskRun.runtimeEnvironmentId,
overrideEnvironmentId: overrideOptions.environmentId,
});
throw new Error("Cannot replay a run into an environment outside its project");
}
}
const authenticatedEnvironment = await findEnvironmentById(
overrideOptions.environmentId ?? existingTaskRun.runtimeEnvironmentId
);
}
}The remediation is complete because it relies on project-level matching rather than user input. By querying both environmental records from the database and demanding strict equivalence of their projectId values, the system prevents cross-project resource pollution.
Exploitation of GHSA-QXPP-QJG8-X4JV requires the attacker to possess a valid account on the target Trigger.dev instance. This grants the attacker the ability to execute their own tasks and perform replay operations. The attacker must also acquire the target environment identifier of the victim's workspace.
With these prerequisites satisfied, the attacker generates a standard HTTP POST request to the task replay endpoint of one of their own tasks. By inserting the victim's environment identifier into the overrideOptions JSON object, the attacker directs the execution context to the victim's workspace.
POST /api/v1/runs/run_attacker_1/replay HTTP/1.1
Host: app.trigger.dev
Authorization: Bearer tr_secret_attacker_api_key
Content-Type: application/json
{
"overrideOptions": {
"environmentId": "victim-environment-id-here"
}
}Upon receiving this request, the vulnerable server schedules the execution of the attacker's tasks inside the victim's environment. The tasks run with the permissions, environment variables, and connections configured in the victim's workspace, leading to unauthorized write operations.
The impact of this Broken Object Level Authorization vulnerability is high, representing a complete breach of tenant isolation. An attacker executing arbitrary tasks inside a victim's environment can read sensitive secrets, manipulate external databases connected to the background tasks, or execute server-side code within the runner infrastructure.
Furthermore, because background tasks are executed on the victim's compute resources, an attacker can consume the victim's execution quotas, resulting in resource exhaustion and financial loss. The scope of exploitation is classified as Changed because the attacker leverages an account in one logical scope to manipulate assets in an entirely separate security domain.
Applying the CVSS v3.1 framework, this vulnerability yields a score of 9.9. The high severity is driven by the ease of exploitation, low privileges required, and severe consequences for confidentiality, integrity, and availability.
To mitigate this vulnerability, administrators of self-hosted Trigger.dev instances must upgrade to version v4.5.2 or later. This release enforces the structural checks required to block cross-project task replays.
For organizations operating self-hosted instances that cannot immediately upgrade, access to the Trigger.dev API and dashboard should be restricted using network-level controls or web application firewall policies. Modifying database records or applying temporary application-level middleware to drop replay requests containing the overrideOptions.environmentId field can also serve as temporary workarounds.
Development teams should establish automated security tests to verify authorization boundaries during API operations. Specifically, test cases should assert that attempting to access, update, or execute resources across different project identifiers results in an authorization failure.
CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:C/C:H/I:H/A:H| Product | Affected Versions | Fixed Version |
|---|---|---|
Trigger.dev Trigger.dev | < 4.5.2 | 4.5.2 |
| Attribute | Detail |
|---|---|
| CWE ID | CWE-639 / CWE-285 |
| Attack Vector | Network |
| CVSS v3.1 Score | 9.9 (Critical) |
| Exploit Status | poc |
| KEV Status | Not Listed |
| Vulnerability Class | Broken Object Level Authorization (BOLA) |
The system fails to check if the user is authorized to access or modify a resource when they provide a direct identifier.
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.
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.
In Natural Language Toolkit (NLTK) versions prior to 3.10.4, the nltk.parse.dependencygraph.dot2img function resolves the Graphviz dot binary through the system PATH using find_binary('dot') and invokes it directly via subprocess.run() instead of routing execution through nltk.pathsec.spawn_trusted(). This omission bypasses file ownership validation, directory writability checks, and dynamic loader environment scrubbing. On multi-user POSIX systems where a victim's PATH contains a directory writable by a local low-privileged attacker, the attacker can plant a malicious dot binary that executes under the victim's privileges when dependency graphs are rendered.
A race condition in Next.js versions 16.3.0 through 16.4.4 allows cross-request cache poisoning and unauthorized information disclosure across root parameters. When an application invokes the same `'use cache'` function both directly during rendering and wrapped inside `unstable_cache()`, a concurrent `unstable_cache()` request arriving during a cold start cache fill joins the in-flight execution. Because the `unstable_cache()` execution context lacks root parameter tracking, the parameter mismatch verification fails, causing `unstable_cache()` to persist root-parameter-scoped data under a global cache key.
CVE-2026-128074 is an algorithmic complexity and Regular Expression Denial of Service (ReDoS) vulnerability in Nuxt versions 4.6.0 through 4.6.3. The flaw resides in the server-side rendering (SSR) runtime components responsible for payload URL generation and experimental early 404 route evaluation. By sending unauthenticated HTTP requests containing long sequences of repeated forward slashes followed by a non-slash character, an attacker can force the V8 regular expression engine into quadratic O(N^2) backtracking, blocking the single-threaded Node.js event loop and degrading application availability.
CVE-2026-128075 (GHSA-96x6-fvhx-49hg) is an information disclosure vulnerability in the Nuxt framework affecting versions 3.0.0 prior to 4.6.4. During Server-Side Rendering (SSR), unhandled non-HTTP exceptions thrown within pages, plugins, or route middleware are automatically wrapped using createError without being flagged as unhandled. Consequently, the production SSR serializer treats these internal exceptions as deliberate public HTTP errors and embeds their raw message and data properties—which frequently contain internal URLs, API credentials, and upstream response payloads—directly into the client-accessible __NUXT_DATA__ hydration state and JSON error responses.