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



CVE-2026-102600

CVE-2026-102600: Unhandled Runtime Exception via Unsafe Prototype Lookup in @socket.io/cluster-engine

Alon Barad
Alon Barad
Software Engineer

Oct 6, 2026·6 min read·22 visits

Executive Summary (TL;DR)

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.

Vulnerability Overview

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.

Root Cause Analysis

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.

Code Analysis

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.

Exploitation Methodology

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.

Impact Assessment

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.

Remediation and Defensive Countermeasures

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.

Fix Analysis (1)

Technical Appendix

CVSS Score
7.5/ 10
CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H
EPSS Probability
0.37%
Top 72% most exploited

Affected Systems

@socket.io/cluster-engine

Affected Versions Detail

Product
Affected Versions
Fixed Version
@socket.io/cluster-engine
Socket.IO
< 0.1.10.1.1
AttributeDetail
CWE IDCWE-20
Attack VectorNetwork
CVSS Score7.5 (High)
EPSS Score0.00366 (Percentile: 28.17%)
ImpactDenial of Service
Exploit StatusNone
KEV StatusNot listed

MITRE ATT&CK Mapping

T1190Exploit Public-Facing Application
Initial Access
CWE-20
Improper Input Validation

The product receives input that is expected to have certain properties or values but does not validate or incorrectly validates these properties.

References & Sources

  • [1]GitHub Security Advisory GHSA-wfpm-5gcm-94cg
  • [2]Official Fix Commit
  • [3]Release Tag @socket.io/cluster-engine@0.1.1
  • [4]NVD Record
  • [5]CVE.org 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

•18 minutes ago•CVE-2026-77382
5.9

CVE-2026-77382: Cryptographic Precision Loss in falcon-rust Discrete-Gaussian Sampler

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.

Amit Schendel
Amit Schendel
1 views•11 min read
•about 1 hour ago•CVE-2026-62955
7.2

CVE-2026-62955: Authenticated Path Traversal and Remote Code Execution via realpath() Bypass in baserCMS BcThemeFileService

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.

Amit Schendel
Amit Schendel
1 views•11 min read
•about 2 hours ago•CVE-2026-63012
6.5

CVE-2026-63012: Authorization Bypass and Information Disclosure in baserCMS Administrative API

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.

Alon Barad
Alon Barad
1 views•9 min read
•about 3 hours ago•CVE-2026-102945
4.9

CVE-2026-102945: Unrecovered Goroutine Panic via Malformed NGAP PathSwitchRequest in Aether Project AMF

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.

Amit Schendel
Amit Schendel
1 views•11 min read
•about 4 hours ago•CVE-2026-103025
8.7

CVE-2026-103025: Unbounded Memory Allocation and Decompression Bomb in bep/imagemeta PNG Parser

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.

Amit Schendel
Amit Schendel
2 views•1 min read
•about 5 hours ago•CVE-2026-103033
5.3

CVE-2026-103033: Pre-Verification Nil-Map Panic and Denial of Service in ALTCHA Go Library

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.

Alon Barad
Alon Barad
2 views•10 min read