Oct 5, 2026·6 min read·73 visits
The @graphql-tools/executor-legacy-ws package failed to validate TLS certificates for outgoing wss:// connections, leaving Node.js applications vulnerable to credential theft and message manipulation via Adversary-in-the-Middle (MitM) attacks.
A vulnerability in @graphql-tools/executor-legacy-ws prior to version 1.1.35 hardcodes the TLS rejectUnauthorized setting to false for outgoing secure WebSocket (wss://) connections. This defect allows unauthenticated remote attackers to perform Adversary-in-the-Middle (MitM) attacks, capturing or tampering with sensitive connection payloads and subscription data.
The @graphql-tools/executor-legacy-ws package is a utility within the graphql-tools ecosystem designed to manage legacy WebSocket connection transports. Specifically, the buildWSLegacyExecutor() function sets up WebSocket endpoints using the older graphql-ws sub-protocol. When initiating a secure outbound WebSocket connection over wss:// within a Node.js runtime environment, the executor is responsible for establishing a cryptographically secure transport layer.
Prior to version 1.1.35, the package contained an architectural flaw where the TLS configuration parameter rejectUnauthorized was hardcoded to false. This parameter controls whether Node.js rejects connections from servers that present invalid, untrusted, or self-signed TLS certificates. Because this verification check was explicitly bypassed, the application failed to establish identity assurance for any remote WebSocket server.
This vulnerability is classified under CWE-295 (Improper Certificate Validation). The attack surface resides primarily in server-side JavaScript applications, backend microservices, or GraphQL gateways that communicate with remote GraphQL APIs over secure WebSockets. Clients executing within native web browsers are unaffected by this vulnerability, as web browsers ignore Node.js-specific WebSocket configurations and strictly enforce system-level certificate validation rules.
The root cause of this vulnerability lies in the implementation of the buildWSLegacyExecutor function within packages/executors/legacy-ws/src/index.ts. When establishing a connection, the function instantiates a WebSocket client using a runtime-defined implementation, typically the ws package in Node.js. During this initialization, configuration parameters are passed to define transport-layer behaviors.
The codebase hardcoded the TLS options inside the constructor arguments. By setting rejectUnauthorized: false, the executor instructed the Node.js tls and https modules to bypass the validation of the peer certificate chain. This bypass disabled critical validation steps, including verifying that the certificate was signed by a trusted root Certificate Authority (CA), checking the expiration date of the certificate, and ensuring that the Common Name (CN) or Subject Alternative Name (SAN) of the certificate matched the destination hostname.
Consequently, the TLS socket failed open, accepting any X.509 certificate presented during the cryptographic handshake. An attacker capable of intercepting traffic at the network routing or DNS resolution layer could easily establish a TLS session using a self-signed or domain-mismatched certificate. The Node.js application would establish the WebSocket tunnel without throwing any warnings or connection errors, completely undermining the confidentiality and integrity assurances of the wss:// scheme.
An analysis of the fix implemented in Pull Request #8426 (commit 3831a0661514c91d99971052f983552556880402) demonstrates the transition to a secure-by-default posture. The vulnerable implementation in packages/executors/legacy-ws/src/index.ts had hardcoded options:
// Vulnerable Code
websocket = new WebSocketImpl(subscriptionsEndpoint, 'graphql-ws', {
followRedirects: true,
headers: options?.headers,
rejectUnauthorized: false, // <-- Hardcoded bypass
skipUTF8Validation: true,
});The security patch introduced an explicit interface option rejectUnauthorized to both LegacyWSExecutorOpts and LoadFromUrlOptions. The default value is resolved using the nullish coalescing operator (?? true), ensuring that if the developer does not configure this option, it defaults securely to true:
// Patched Code
websocket = new WebSocketImpl(subscriptionsEndpoint, 'graphql-ws', {
followRedirects: true,
headers: options?.headers,
rejectUnauthorized: options?.rejectUnauthorized ?? true, // <-- Secure default
skipUTF8Validation: true,
});This remediation ensures that Node.js validates the entire certificate chain against its list of trusted root authorities. The patch is cryptographically complete; it restores native validation rules by default while preserving functionality for developers who must explicitly disable validation when testing against local, self-signed mock environments.
To exploit this vulnerability, an attacker must position themselves on the network path between the vulnerable Node.js client application and the target GraphQL WebSocket server. This can be achieved through techniques such as local network ARP poisoning, DNS spoofing, or router compromising. The attacker does not need prior authentication to execute this attack.
Once positioned, the execution proceeds as follows:
During step 2, the attacker's gateway presents an arbitrary, self-signed certificate. Because of the vulnerability, the client skips certificate validation and establishes a secure-looking connection. During step 5, the client transmits subscription payloads, which routinely carry highly sensitive parameters inside HTTP headers or the connectionParams configuration object, such as authorization bearer tokens or user session identifiers. The attacker decrypts this outbound communication, extracts the secrets, and gains full access to downstream data feeds.
The security impact of CVE-2026-103921 is significant for enterprise backends that rely on real-time subscriptions. The CVSS base score of 7.4 reflects a high-severity threat. Since the attacker must establish an Adversary-in-the-Middle position, the Attack Complexity (AC) metric is rated as High. However, no privileges (PR:N) or user interactions (UI:N) are required to complete the exploitation.
Successful exploitation results in a complete loss of confidentiality and integrity for the affected WebSocket channel. Because WebSockets are designed for bidirectional, long-lived communications, attackers can not only harvest static credentials but also manipulate incoming message feeds. In systems tracking financial data, system events, or industrial monitoring, the injection of malicious data packets into the application flow could trigger secondary, critical logic failures.
The scope is limited to systems operating in server-side environments where JavaScript packages directly negotiate raw TLS streams. Desktop client applications developed with frameworks like Electron may also be affected if they employ these tools inside their background Node processes.
Remediation requires upgrading the underlying dependencies of the graphql-tools ecosystem. Developers should upgrade @graphql-tools/executor-legacy-ws to version 1.1.35 or higher. Applications that consume this executor transitively through @graphql-tools/url-loader must upgrade that package to version 9.1.8 or higher, which forces resolution of the patched executor.
In scenarios where third-party APIs use self-signed certificates in isolated, internal Virtual Private Clouds (VPCs), developers should avoid global environment overrides such as NODE_TLS_REJECT_UNAUTHORIZED=0, as this disables security globally. Instead, use the newly introduced rejectUnauthorized configuration property to surgically override validation checks only in local development environments.
Additionally, implementing active security monitoring at the network layer, such as deploying Intrusion Detection Systems (IDS) that flag unexpected TLS handshakes or unauthorized certificate changes, will help detect unauthorized MitM attempts.
CVSS:3.1/AV:N/AC:H/PR:N/UI:N/S:U/C:H/I:H/A:N| Product | Affected Versions | Fixed Version |
|---|---|---|
@graphql-tools/executor-legacy-ws Arda Tanrikulu | < 1.1.35 | 1.1.35 |
@graphql-tools/url-loader Arda Tanrikulu | < 9.1.8 | 9.1.8 |
| Attribute | Detail |
|---|---|
| CWE ID | CWE-295 (Improper Certificate Validation) |
| Attack Vector | Network (Requires MitM positioning) |
| CVSS v3.1 Score | 7.4 (High Severity) |
| EPSS Score | 0.00268 (Percentile: 17.20%) |
| Exploit Status | No public functional exploit payload available |
| CISA KEV Status | Not listed |
| Ransomware Association | No known usage |
The application does not validate, or incorrectly validates, an association between an identity and a certificate, which can allow an attacker to spoof a trusted entity.
A pre-authentication path traversal vulnerability exists in Etherpad versions 1.8.14 prior to 3.3.3 within the `/static/*` plugin asset handler. In `src/node/utils/Minify.ts`, an unconditional backslash-to-forward-slash conversion is executed after pathname sanitization has already concluded. On POSIX systems, this transforms benign backslash characters into directory traversal sequences (`../`), allowing unauthenticated remote attackers to read arbitrary files from the host filesystem, extract administrative credentials from `settings.json`, and achieve remote code execution via the plugin installation interface.
A local sandbox escape vulnerability exists in the Natural Language Toolkit (NLTK) versions 3.9.4 through 3.10.3 within its ZIP archive extraction implementation. Due to a type mismatch in member resolution and a failure to inspect filesystem link counts (st_nlink > 1), the extraction routine follows pre-planted hardlinks inside the extraction root, allowing a local attacker to truncate and overwrite arbitrary out-of-root files writable by the executing process.
CVE-2026-129304 is an improper input validation and Redis glob pattern injection vulnerability in Guard Core versions 1.0.0 through 3.12.0. The header parsing routine _extract_from_forwarded_header() extracts values from the X-Forwarded-For HTTP header without verifying that the extracted substring is a valid IPv4 or IPv6 address. In deployments configured with trusted_proxies where the target header index is client-controllable, arbitrary strings containing Redis glob metacharacters reach BehaviorTracker and are interpolated directly into Redis key names and blocking KEYS queries. This allows unauthenticated attackers to aggregate cross-client behavioral metrics, trigger false-positive rate limits, cause denial of service via O(N) Redis keyspace scans, or raise unhandled ValueError exceptions during automated IP ban operations.
iSponsorBlockTV prior to version 2.11.0 contains a blind Server-Side Request Forgery (SSRF) vulnerability in its Simple Service Discovery Protocol (SSDP) and Discovery and Launch (DIAL) client implementation. During local device discovery, the application processes SSDP responses without validating that the URL specified in the LOCATION header or the subsequent application-url response header matches the IP address of the responding UDP host. An adjacent network attacker can spoof SSDP responses to induce the iSponsorBlockTV host to send arbitrary HTTP GET requests and constrained HTTP POST requests to internal network endpoints or loopback services.
CVE-2026-121707 is a high-severity Regular Expression Denial of Service (ReDoS) vulnerability in the Effect TypeScript library prior to version 3.22.1. When evaluating untrusted input against Schema.TemplateLiteral definitions containing multiple string spans, the dynamically compiled regular expression exhibits polynomial backtracking complexity. Because JavaScript runtimes execute on a single-threaded event loop, processing specially crafted non-matching strings causes synchronous CPU starvation and complete application unresponsiveness.
CVE-2026-75518 is an incorrect authorization and privilege assignment vulnerability in the DOMShell Model Context Protocol (MCP) server (@apireno/domshell) prior to version 2.0.8. The server classified the domshell_eval tool and the eval command as read-tier operations, permitting their execution without the --allow-write flag. Because the eval command dispatches through the same Chrome DevTools Protocol (CDP) Runtime.evaluate pipeline as the write-tier js command without enabling the throwOnSideEffect constraint, callers restricted to read-only sessions can execute state-mutating JavaScript in the browser context while host user interfaces and audit logs record the activity as read-only.