Disclaimer: This content was generated using AI. While we strive for accuracy, please verify critical information with official sources.
Sources: National Vulnerability Database, CISA KEV, Exploit-DB
CVE-2026-112309 Overview
CVE-2026-112309 is a prototype pollution vulnerability in the @rvf/set-get npm package versions prior to 7.0.4. The flaw resides in the setPath function, which fails to distinguish between own and inherited properties when traversing object paths. Unauthenticated attackers can submit a form field named hasOwnProperty.call through @rvf/core form parsing to overwrite shared built-in function properties on Object.prototype. The result is a process-wide denial of service that persists until the Node.js process restarts. The vulnerability is tracked under CWE-1321: Improperly Controlled Modification of Object Prototype Attributes.
Critical Impact
Remote unauthenticated attackers can trigger process-wide denial of service against any Node.js application using @rvf/core form parsing backed by vulnerable @rvf/set-get versions.
Affected Products
- @rvf/set-get versions prior to 7.0.4
- @rvf/core applications using the vulnerable setPath dependency
- Node.js server applications performing form parsing with the rvf library
Discovery Timeline
- 2026-10-19 - CVE-2026-112309 published to the National Vulnerability Database
- 2026-10-22 - Last updated in NVD database
Technical Details for CVE-2026-112309
Vulnerability Analysis
The @rvf/set-get package provides path-based object mutation utilities used by the rvf form framework. The setPath function walks a dotted or bracketed path and creates intermediate objects as needed. Before version 7.0.4, the function used obj[part] === undefined to detect missing keys. This check traverses the prototype chain and returns a defined value for inherited methods such as hasOwnProperty, toString, and valueOf. When an attacker supplies a path that collides with an inherited method name, setPath descends into the shared function rather than creating a new own property.
Subsequent assignments then replace the method on the shared built-in, affecting every object in the process. Because Object.prototype.hasOwnProperty is called by countless libraries and runtime code paths, replacing it with a non-function value causes immediate TypeError exceptions across the application until the process is restarted.
Root Cause
The root cause is unsafe property existence checking in setPath. The expression obj[part] === undefined matches inherited properties, allowing a path segment like hasOwnProperty to resolve to the function on Object.prototype. The code then treats the inherited function as a traversal target and mutates it. The patch replaces the check with Object.hasOwn(obj, part) so only own properties are considered during descent.
Attack Vector
An attacker submits a crafted HTTP form payload to any endpoint handled by @rvf/core. A field named hasOwnProperty.call or similar nested inherited-method path is sufficient. The form parser invokes setPath, which pollutes the shared prototype function. Subsequent requests on the same process fail, producing an unauthenticated denial of service without the attacker needing valid credentials or user interaction.
if (typeof part === "string" && REJECT_KEYS.includes(part))
throw new Error(`Attempted to set a forbidden key: ${part}`);
- if (obj[part] === undefined) {
+ // Use Object.hasOwn to only check own properties.
+ // obj[part] === undefined matches inherited properties too,
+ // which allows prototype pollution (e.g. hasOwnProperty calls the
+ // function from Object.prototype instead of creating a new key).
+ if (!Object.hasOwn(obj, part)) {
if (typeof nextPart === "number") {
obj[part] = [];
} else {
Source: GitHub Commit 4a5e118 - this patch replaces the undefined check with Object.hasOwn so setPath no longer descends into inherited properties.
Detection Methods for CVE-2026-112309
Indicators of Compromise
- Form submissions containing field names that match inherited Object.prototype members such as hasOwnProperty, hasOwnProperty.call, toString, valueOf, or constructor.prototype.
- Unhandled TypeError: X is not a function exceptions in Node.js logs referencing hasOwnProperty, toString, or other built-in methods.
- Sudden cascading request failures across unrelated endpoints following a specific POST request, resolving only after a process restart.
Detection Strategies
- Inspect HTTP request bodies and query strings for parameter names containing dotted paths that reference Object.prototype methods.
- Alert on repeated process crashes or restarts of Node.js services that depend on @rvf/core or @rvf/set-get.
- Perform software composition analysis (SCA) on package-lock.json and yarn.lock files to flag @rvf/set-get versions below 7.0.4.
Monitoring Recommendations
- Enable structured logging of request handlers to capture submitted form field names for post-incident analysis.
- Monitor Node.js process health metrics including uptime, exception counts, and memory for abrupt deviations correlated with inbound traffic spikes.
- Centralize application exception telemetry so prototype-pollution-induced TypeError patterns can be correlated across hosts.
How to Mitigate CVE-2026-112309
Immediate Actions Required
- Upgrade @rvf/set-get to version 7.0.4 or later across all affected services.
- Audit dependency trees for transitive installations of vulnerable @rvf/set-get releases pulled in through @rvf/core or other packages.
- Deploy input validation at the edge to reject form field names containing hasOwnProperty, constructor, __proto__, prototype, toString, or valueOf.
Patch Information
The fix was committed to the rvf repository as commit 4a5e118 and shipped in @rvf/set-get 7.0.4. The patch replaces the inherited-property check with Object.hasOwn(obj, part) inside setPath.ts. Additional context is available in the VulnCheck Security Advisory and the pre-patch sources: setPath.ts and flatten.ts.
Workarounds
- Place a web application firewall (WAF) rule in front of affected services to block form fields referencing prototype or inherited-method names.
- Freeze Object.prototype at process startup using Object.freeze(Object.prototype) to prevent runtime mutation, after validating application compatibility.
- Restart affected Node.js processes immediately on detection of prototype pollution to restore built-in method behavior.
# Upgrade the vulnerable package to the patched release
npm install @rvf/set-get@^7.0.4
# Verify no vulnerable versions remain in the dependency tree
npm ls @rvf/set-get
# Optional runtime hardening at application entry point
node -e "Object.freeze(Object.prototype); require('./server.js')"
Disclaimer: This content was generated using AI. While we strive for accuracy, please verify critical information with official sources.
Sources: National Vulnerability Database, CISA KEV, Exploit-DB

