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-101911 Overview
The ip-address JavaScript library contains a resource exhaustion vulnerability [CWE-400] in versions prior to 10.7.1. The Address6 constructor, Address6.isValid, and parse code in src/ipv6.ts accept unbounded input strings. Invalid characters are expanded through the RE_BAD_CHARACTERS regular expression into large diagnostic outputs. Megabyte-scale attacker-controlled fields can cause synchronous stalls and high transient memory use. Input around 16 MiB triggers an invalid string length exception, and approximately 32 MiB causes process termination. Applications that pass large, unbounded fields to Address6 parsing without prior length validation are affected.
Critical Impact
Attackers who reach the parser with a 32 MiB field can terminate the Node.js process, producing a denial-of-service condition against services that use ip-address on untrusted input.
Affected Products
- ip-address npm package versions prior to 10.7.1
- Applications invoking Address6.isValid on untrusted input
- Applications invoking the Address6 constructor or parse paths on untrusted input
Discovery Timeline
- 2026-09-28 - CVE-2026-101911 published to NVD
- 2026-09-30 - Last updated in NVD database
Technical Details for CVE-2026-101911
Vulnerability Analysis
The vulnerability is a resource exhaustion issue in the IPv6 parsing path of the ip-address library. When the parser encounters invalid characters, it wraps each offending character in a diagnostic span using the RE_BAD_CHARACTERS regular expression. The diagnostic output grows proportionally to the input length rather than to a valid address size. Passing a multi-megabyte string produces a synchronous stall while the engine constructs the diagnostic. Input of roughly 16 MiB triggers a V8 invalid string length exception, and input near 32 MiB terminates the process.
Common URL, header, and body-parser default limits typically prevent 32 MiB fields from reaching application code. The vulnerability becomes exploitable when an application accepts large fields, for example through file uploads, JSON APIs with raised limits, or WebSocket messages, and forwards them to Address6 without a prior length check.
Root Cause
The Address6 constructor and isValid did not enforce a maximum input length before parsing. The parser's diagnostic generation scales with input size, so unbounded input produces unbounded work and memory allocation.
Attack Vector
An unauthenticated remote attacker submits a large string, containing invalid IPv6 characters, to any endpoint that eventually calls Address6.isValid or constructs an Address6. Availability of the affected process is impacted.
// Patch in src/ipv6.ts — reject input longer than the family allows before parsing.
address = address.replace(constants6.RE_ZONE_STRING, '');
}
+ // The longest well-formed address is all but the last two groups written
+ // as four hex digits with their colons, then a 15-character dotted quad:
+ // 5 * (groups - 2) + 15, which is 45 for eight groups, the same line
+ // CPython's ipaddress module draws. Rejecting longer input here keeps the
+ // parse diagnostics, which wrap every offending character in a span,
+ // proportional to an address rather than to whatever was passed in.
+ const longest = this.groups * 5 + 5;
+
+ if (address.length > longest) {
+ throw new AddressError(`IPv6 addresses are at most ${longest} characters.`);
+ }
+
this.addressMinusSuffix = address;
this.parsedAddress = this.parse(this.addressMinusSuffix);
Source: GitHub Commit Fix
A parallel bound was added to src/ipv4.ts:
address = address.replace(constants.RE_SUBNET_STRING, '');
}
+ // Four three-digit octets and three dots: the longest well-formed address
+ // is 15 characters. Longer input is rejected before parsing, as Address6
+ // does at its own limit.
+ const longest = constants.GROUPS * 4 - 1;
+
+ if (address.length > longest) {
+ throw new AddressError(`IPv4 addresses are at most ${longest} characters.`);
+ }
+
this.addressMinusSuffix = address;
this.parsedAddress = this.parse(address);
Source: GitHub Commit Fix
Detection Methods for CVE-2026-101911
Indicators of Compromise
- HTTP requests containing fields larger than 1 MiB that reach IP validation code paths.
- Node.js process crashes with RangeError: Invalid string length traceable to ip-address frames.
- Sudden spikes in resident memory or event-loop lag on services performing IP parsing.
Detection Strategies
- Inventory dependencies with npm ls ip-address and flag any transitive versions below 10.7.1.
- Add application-level assertions that reject IP inputs longer than 45 characters before invoking Address6.
- Capture stack traces on unhandled RangeError and AddressError events to surface exploitation attempts.
Monitoring Recommendations
- Monitor process restart counts and out-of-memory events for Node.js services exposing IP-handling endpoints.
- Alert on request bodies or header values exceeding expected size thresholds for endpoints that parse IP addresses.
- Track event-loop lag metrics; sustained multi-second stalls warrant investigation of parser inputs.
How to Mitigate CVE-2026-101911
Immediate Actions Required
- Upgrade ip-address to version 10.7.1 or later across all direct and transitive dependencies.
- Enforce strict length limits on any user-supplied field routed to Address6.isValid or the Address6 constructor.
- Review body-parser, WebSocket, and file-upload configurations to confirm defaults have not been raised above 1 MiB for IP-carrying fields.
Patch Information
The issue is fixed in ip-address 10.7.1. The fix adds an early length check that rejects IPv6 input longer than 45 characters and IPv4 input longer than 15 characters, keeping parse-time diagnostics bounded. See the GitHub Security Advisory GHSA-h3mg-xc3c-68pw and GitHub Release v10.7.1 for details.
Workarounds
- Wrap calls to Address6.isValid and the Address6 constructor with a length guard rejecting strings longer than 45 characters.
- Reduce body-parser and framework input size limits to values well below 1 MiB for endpoints that accept IP addresses.
- Validate content type and reject non-string payloads before invoking IP parsing routines.
# Upgrade the vulnerable dependency
npm install ip-address@^10.7.1
npm ls ip-address
# Quick pre-parse guard example (Node.js)
# if (typeof input !== 'string' || input.length > 45) return false;
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

