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-XXV7-2VV3-H682

CVE-2026-85650: Server-Side Request Forgery in Trigger.dev Webhook Alert Channel Delivery

Alon Barad
Alon Barad
Software Engineer

Oct 2, 2026·7 min read·16 visits

Executive Summary (TL;DR)

Unvalidated webhook URLs in Trigger.dev allow authenticated users to perform server-side requests against internal services and cloud metadata endpoints.

A critical Server-Side Request Forgery (SSRF) vulnerability in Trigger.dev prior to version 4.5.2 allows authenticated organization members to configure webhook alert channels with unvalidated target URLs. This can lead to internal network scanning and cloud metadata extraction.

Vulnerability Overview

The Trigger.dev control plane web application provides a developer-focused platform to orchestrate background jobs and long-running tasks. To notify administrators of runtime anomalies or task failures, the platform implements alert channels, including HTTP webhooks. When an alert condition is met, the backend system invokes an asynchronous worker to dispatch a notification payload to the configured endpoint.

The vulnerability identified as CVE-2026-85650 (GHSA-xxv7-2vv3-h682) is a Server-Side Request Forgery (SSRF) flaw in this notification delivery mechanism. Versions of the platform prior to 4.5.2 fail to validate or sanitize user-supplied URLs before invoking outbound HTTP requests. Any authenticated user with organization access can register an alert channel pointing to internal resources, exposing the internal environment to unauthorized interaction.

Because the system initiates connections from its own network context, an attacker can leverage the platform as an SSRF proxy. This permits reconnaissance of internal networks, interrogation of local loopback services, and unauthorized access to cloud Instance Metadata Services (IMDS).

Root Cause Analysis

The root cause of CVE-2026-85650 is a multi-layered validation failure within the application database schemas and HTTP client implementation. During alert channel registration, the system does not enforce strict syntactic or structural validation on the destination URL. The Zod schemas responsible for parsing user input only verify that the provided string matches a basic string pattern without imposing domain restrictions or address constraints.

At the database level, the ProjectAlert and associated tables store the unchecked string as a legitimate webhook target. The application relies on global Node.js fetch engines to perform the request execution inside background workers. These worker components execute the HTTP POST requests directly without performing pre-resolution domain checks, address family checks, or private IP filtering.

Additionally, the application lacks connection-bound socket validation, exposing it to DNS rebinding attacks. An attacker can configure a domain that resolves to a public IP during initial inspection but shifts to an internal loopback address during connection initiation. The absence of strict redirection policies further compounds the risk, allowing the client to follow server-instructed redirects to internal subnets.

Code Analysis

In vulnerable versions of Trigger.dev, the database validation schema accepts arbitrary strings for the webhook URL. The model schema apps/webapp/app/models/projectAlert.server.ts uses the z.string() validator rather than enforcing network-safe constraints. This permits loopback and non-routable IP addresses to be successfully stored in the database.

The outbound delivery logic is managed by apps/webapp/app/v3/services/alerts/deliverAlert.server.ts. The worker fetches the URL string directly from the database record and invokes the global fetch API without an isolated agent.

// Vulnerable Implementation
const response = await fetch(webhook.url, {
  method: "POST",
  headers: {
    "content-type": "application/json",
    "x-trigger-signature-hmacsha256": signatureHex,
  },
  body: rawPayload,
  signal: AbortSignal.timeout(5000),
});

To remediate this, the patch introduced in commit 34b1a181c2a1d33a53ebab88f84b05f81fea4254 adds multiple protection layers. The custom safeWebhookFetch service replaces standard fetch, enforcing a socket-level DNS lookup check to reject private IP ranges prior to connection.

// Patched Implementation: Socket-level lookup validation
const safeLookup: LookupFunction = (hostname, options, callback) => {
  dnsPromises
    .lookup(hostname, {
      all: true,
      family: options.family,
      hints: options.hints,
      verbatim: options.verbatim,
    })
    .then((addresses) => {
      try {
        for (const { address, family } of addresses) {
          assertAddressAllowed(address, family);
        } 
      } catch (err) {
        callback(err as NodeJS.ErrnoException, []);
        return;
      }
      if (options.all) {
        callback(null, addresses);
      } else {
        callback(null, addresses[0].address, addresses[0].family);
      }
    })
    .catch((err) => callback(err as NodeJS.ErrnoException, []));
};

Exploitation Methodology

Exploitation of this vulnerability requires authenticated access to a Trigger.dev organization. An attacker with standard membership privileges can register a new alert channel pointing to a protected internal IP or a cloud metadata service endpoint. Because organization registration is open in self-hosted deployments and accessible via compromised tokens in cloud environments, the barrier to entry is minimal.

The attacker sends an HTTP POST request to the alert channels API endpoint, specifying the target internal host within the payload. The user then forces a background task run failure, prompting the backend task orchestrator to generate an alert event. The system identifies the webhook channel, generates a signature, and transmits the payload to the internal server.

Although the response payload is not fully returned to the attacker, the behavior is classified as semi-blind. The attacker can extract system state information by reviewing connection latency, HTTP status codes, and network error logs rendered in the web dashboard. This allows for rapid host discovery and service mapping across the hosting environment.

Impact Assessment

The primary consequence of this vulnerability is the exposure of internal-only network infrastructure to unauthorized authenticated actors. By proxying requests through the Trigger.dev backend, attackers can reach services running on the loopback interface (127.0.0.1) that are not exposed to the public internet. This includes local administration portals, database management ports, and internal microservice APIs.

In cloud-hosted deployments, the threat extends to the Instance Metadata Service (IMDS). An attacker targeting http://169.254.169.254/latest/meta-data/ can obtain cloud credentials, IAM roles, and configuration parameters assigned to the webapp container. This can lead to lateral movement and full cloud account compromise depending on the permissions granted to the application host.

The CVSS v3.1 base score is rated at 7.7 (High) reflecting the scope change (S:C) associated with traversing the security boundary from the public application web server to internal cloud infrastructure. The vulnerability is categorized under CWE-918 (Server-Side Request Forgery) and maps to MITRE ATT&CK techniques T1190 (Exploit Public-Facing Application) and T1005 (Data from Local System).

Remediation Analysis

Remediation of CVE-2026-85650 requires upgrading self-hosted instances of Trigger.dev to version 4.5.2 or above. The official patch implements a comprehensive defensive framework that blocks private IP ranges and addresses DNS rebinding. This is achieved by binding IP validation directly to the connection lookup phase rather than relying on pre-resolve hooks.

// IP verification logic implemented in safeWebhookUrl.server.ts
function isUnsafeIPv4(host: string): boolean {
  const parts = host.split(".");
  if (parts.length !== 4) return false;
  const nums = parts.map((p) => Number(p));
  if (nums.some((n) => !Number.isInteger(n) || n < 0 || n > 255)) return false;
  const [a, b] = nums;
  if (a === 0) return true; // unspecified
  if (a === 127) return true; // loopback
  if (a === 10) return true; // RFC 1918 Private
  if (a === 172 && b >= 16 && b <= 31) return true; // RFC 1918 Private
  if (a === 192 && b === 168) return true; // RFC 1918 Private
  if (a === 169 && b === 254) return true; // link-local (IMDS)
  if (a === 100 && b >= 64 && b <= 127) return true; // carrier-grade NAT
  if (a >= 224 && a <= 239) return true; // multicast
  if (a >= 240) return true; // reserved
  return false;
}

For environments where immediate patching is not possible, network-level egress filtering must be enforced. Administrators should apply firewall rules or security groups restricting outbound traffic from the application web workers to internal subnets. Cloud environments must enforce IMDSv2 and restrict hop limits to mitigate the risk of metadata extraction.

Regular security audits should include querying the database for existing non-public webhook registrations. Organizations running self-hosted deployments can run automated scripts to inspect active webhook targets and confirm compliance with internal security policies.

Official Patches

Trigger.devPull Request #4199 fixing SSRF in alert channel delivery

Fix Analysis (1)

Technical Appendix

CVSS Score
7.7/ 10
CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:C/C:H/I:N/A:N
EPSS Probability
0.35%
Top 74% most exploited

Affected Systems

Trigger.dev Control Plane WebappTrigger.dev Self-Hosted Web Application

Affected Versions Detail

Product
Affected Versions
Fixed Version
trigger.dev
Trigger.dev
< 4.5.24.5.2
AttributeDetail
CWE IDCWE-918 (Server-Side Request Forgery)
Attack VectorNetwork (AV:N)
CVSS v3.1 Base Score7.7 (High)
EPSS Score0.00348
Exploit StatusPoC (Proof of Concept Available)
KEV StatusNot Listed

MITRE ATT&CK Mapping

T1190Exploit Public-Facing Application
Initial Access
T1005Data from Local System
Collection
CWE-918
Server-Side Request Forgery (SSRF)

The web application receives a user-specified URL and sends a request to it without fully validating the destination.

Known Exploits & Detection

GitHub Security AdvisoryExploit methodology and remediation report for the webhook delivery SSRF.

References & Sources

  • [1]GitHub Advisory GHSA-xxv7-2vv3-h682
  • [2]Official Patch Commit
  • [3]Trigger.dev Release v4.5.2
  • [4]Authoritative CVE Record

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-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
2 views•9 min read
•about 2 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 3 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 4 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 5 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
•about 6 hours ago•CVE-2026-128134
7.8

CVE-2026-128134: Local Code Execution via Untrusted Search Path in NLTK dependencygraph

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.

Amit Schendel
Amit Schendel
4 views•11 min read