Oct 6, 2026·6 min read·22 visits
Unauthenticated remote attackers can trigger a Node.js process crash and Denial of Service in @socket.io/cluster-engine by passing prototype-inherited properties as session IDs.
A critical Denial of Service (DoS) vulnerability exists in @socket.io/cluster-engine before version 0.1.1. Unauthenticated remote attackers can crash the server process by supplying inherited prototype property names as session identifiers.
The @socket.io/cluster-engine package is an essential component designed to coordinate clustered engine deployments within the socket.io ecosystem. This component manages client socket session states and synchronizes them across multiple worker processes. The vulnerability, designated as CVE-2026-102600, represents a failure to validate user-controlled input keys before dynamically reading object properties.
An unauthenticated remote attacker can exploit this flaw to trigger a denial of service on target application nodes. By providing a specially crafted session identifier during handshakes or cluster messaging, the attacker causes the application to retrieve properties from the base JavaScript object prototype. This bypasses the registry check and leads to fatal runtime exceptions that crash the Node.js process.
The weakness lies in how JavaScript lookup mechanics resolve properties on plain objects. When the package performs an implicit lookup for a socket session, the absence of explicit checks allows the engine to retrieve base prototype constructors as valid client objects. Because this occurs in critical, unhandled event paths, the subsequent execution failure terminates the host process immediately.
JavaScript applications frequently utilize plain objects ({}) as dynamic associative arrays or key-value lookup tables. In standard ECMAScript implementations, these plain objects inherit a variety of default properties and helper functions from Object.prototype. These default properties include built-in keys like __proto__, constructor, toString, and hasOwnProperty.
When a program performs a bracket lookup (e.g., this.clients[sid]) with user-supplied input, JavaScript evaluates whether the key exists directly on the target object. If the key is not defined as an own property, the runtime engine traverses up the prototype chain. If the key matches a prototype property name like __proto__, the lookup evaluates to Object.prototype instead of returning undefined.
In @socket.io/cluster-engine versions prior to 0.1.1, the internal client registry this.clients was stored as a plain JavaScript object. The lookup logic did not verify if the requested key was a direct, own property of the registry. Consequently, supplying __proto__ as the session ID returned a valid, truthy object, bypassing basic presence checks and setting up the application for downstream type errors.
The vulnerability is localized to several lookup locations within the ClusterEngine class defined in packages/socket.io-cluster-engine/lib/engine.ts. The following diagram illustrates the flow of a message packet containing a malicious session identifier:
Prior to the patch, when processing cluster messages of type MessageType.PACKET, the engine resolved the socket client using direct index access with the session ID (message.data.sid). Because the application does not validate the structure of the incoming session identifier, an attacker can input a reserved prototype key.
// Vulnerable code in engine.ts before 0.1.1
case MessageType.PACKET: {
const client = this.clients[message.data.sid];
if (!client) {
return;
}
// If sid is '__proto__', client evaluates to Object.prototype
// This throws a TypeError since Object.prototype has no onPacket method
client.onPacket(message.data.packet);
}The fix introduces a defensive lookup function named safeGet. This helper enforces that only own properties of the lookup dictionary are returned, preventing prototype traversal.
// Patched implementation in engine.ts
function safeGet<T>(obj: Record<string, T>, key: string): T | undefined {
if (Object.prototype.hasOwnProperty.call(obj, key)) {
return obj[key];
}
}By passing all dynamic lookups through safeGet(this.clients, sid), any attempt to query __proto__ or constructor will return undefined, resolving the lookup safely and terminating execution before invoking non-existent properties on standard JavaScript built-ins.
To execute the denial of service vector, an attacker must target the exposed socket-coordinating paths of an application leveraging @socket.io/cluster-engine. No authentication is required to interact with the engine. The attacker must only possess the ability to transmit crafted messages or connection handshakes directly to the exposed cluster transport interface.
The attack begins when the client establishes a standard Socket.IO connection request, supplying a reserved keyword like __proto__ inside the sid query parameter. Alternatively, the attacker can send a direct cluster messaging frame containing the malicious session ID payload. Because the framework attempts to map the session ID to an active state, the internal routing logic triggers the lookup sequence.
Once the lookup resolves to the base prototype, the engine treats it as a legitimate connection client and attempts to invoke event hooks. This immediate attempt to execute class-specific methods on Object.prototype causes the application thread to throw a TypeError. Because these events are processed within asynchronous callbacks without global error boundaries, the exception bubbles up, forcing Node.js to exit the main thread.
The security impact of CVE-2026-102600 is classified as high, receiving a CVSS base score of 7.5. The primary consequence is a complete Denial of Service (DoS) of the affected application server. The vulnerability does not directly expose application data, modify system configurations, or permit arbitrary code execution.
However, in clustered Node.js environments, worker nodes are typically designed to auto-restart upon a crash. A continuous stream of malicious payloads targeting the prototype properties will repeatedly crash any newly spawned worker processes. This dynamic creates a persistent resource exhaustion state, blocking all legitimate client traffic indefinitely.
Because the socket endpoints are publicly accessible to facilitate client handshakes, the attack vector has high reachability. An attacker does not require any special privileges or specialized network tools to deliver the crashing payload.
The primary remediation path is upgrading the @socket.io/cluster-engine dependency to version 0.1.1 or higher. This update replaces all direct object indexing inside the handshake and socket event paths with the defensive safeGet helper. The updated library successfully handles prototype lookup bypasses by falling back to standard missing-client behaviors.
If upgrading is not immediately possible, organizations can apply temporary mitigations at the application layer or reverse proxy tier. A reverse proxy or web application firewall can inspect incoming request query strings for socket paths. Requests with query parameters matching sid=__proto__, sid=constructor, or sid=prototype should be dropped immediately before they reach the Node.js application process.
Additionally, developers should adopt secure coding standards to prevent prototype-based lookups in other areas of their codebase. Initializing lookup dictionaries using Object.create(null) removes the prototype chain entirely, ensuring that properties like __proto__ resolve to undefined by default without helper wrappers.
CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H| Product | Affected Versions | Fixed Version |
|---|---|---|
@socket.io/cluster-engine Socket.IO | < 0.1.1 | 0.1.1 |
| Attribute | Detail |
|---|---|
| CWE ID | CWE-20 |
| Attack Vector | Network |
| CVSS Score | 7.5 (High) |
| EPSS Score | 0.00366 (Percentile: 28.17%) |
| Impact | Denial of Service |
| Exploit Status | None |
| KEV Status | Not listed |
The product receives input that is expected to have certain properties or values but does not validate or incorrectly validates these properties.
A cryptographic soundness defect in the discrete-Gaussian sampler of falcon-rust prior to version 0.2.0 degrades acceptance-probability precision to approximately 2^-33. By evaluating exponential approximations using 32-bit fractional fixed-point arithmetic (FixedPoint64) and left-shifting polynomial inputs by 31 bits, the implementation violates Falcon's required precision bound of 2^-40 to 2^-46, invalidating the theoretical security reduction against statistical private key leakage.
CVE-2026-62955 is an authenticated path traversal vulnerability in baserCMS affecting versions 5.2.3 up to, but not including, 5.3.0. The flaw resides in the BcThemeFileService::getFullpath() method within the bc-theme-file plugin and represents an incomplete remediation of CVE-2026-30940. Because the path containment check relies on PHP's realpath() returning a non-false value, supplying a nonexistent theme subdirectory causes the verification guard to be skipped entirely. An authenticated administrator can exploit this flaw to read, write, overwrite, or delete arbitrary files within the permissions of the PHP process, leading to remote code execution when executable PHP files are written to the webroot.
CVE-2026-63012 is an authorization bypass and information disclosure vulnerability in baserCMS versions prior to 5.3.0. An architectural flaw in the authentication service configuration combined with overly permissive API access control rules allows low-privileged operator accounts to query restricted administrative API endpoints by supplying a matching HTTP Referer header.
CVE-2026-102945 is a denial-of-service vulnerability affecting the Access and Mobility Management Function (AMF) of the Aether Project (omec-project/amf) prior to version 3.1.6. When processing an NGAP PathSwitchRequest message over the 3GPP N2 interface, the HandlePathSwitchRequest function fails to verify the byte slice lengths of extensible APER bit strings inside the UESecurityCapabilities Information Element before accessing index zero. Because the NGAP receive goroutine lacks a panic recovery handler, supplying a zero-length bit string triggers an out-of-bounds slice read panic that terminates the entire AMF daemon.
CVE-2026-103025 (GHSA-7hvw-3c2q-45qg) is a high-severity denial-of-service (DoS) vulnerability in github.com/bep/imagemeta prior to version 0.17.3. The PNG metadata parser fails to validate declared chunk lengths prior to heap buffer allocation (CWE-789) and inflates zlib-compressed zTXt IPTC chunks without an output size limit (CWE-409). Additionally, out-of-bounds slice indexing in the PNG zTXt handler and IPTC character set resolver allows remote attackers to trigger runtime panics.
CVE-2026-103033 (GHSA-gfwj-45pc-w6r5) is an unauthenticated pre-verification Denial of Service (DoS) vulnerability in the Go implementation of the ALTCHA bot-prevention library (github.com/altcha-org/altcha-lib-go). In versions 2.0.0 and 2.0.1, the internal function parseServerSignature conditionally initializes the ServerSignatureVerificationData.Extra map only when url.ParseQuery returns no error. When an attacker submits a payload containing both an unrecognized query parameter and malformed percent-encoding in the VerificationData field, url.ParseQuery returns partially parsed parameters alongside an error. Because execution continues without initializing the Extra map, the subsequent loop attempts to write unknown parameters into a nil map, triggering a fatal Go runtime panic before cryptographic signature verification occurs.