Skip to main content

Immutable.js EUVDEUVD-2026-42318

| CVE-2026-59879 HIGH
Integer Overflow or Wraparound (CWE-190)
2026-07-08 GitHub_M GHSA-v56q-mh7h-f735
8.7
CVSS 4.0 · Vendor: GitHub_M
View

Attack ChainAIDerived

Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain

  1. Access
    Identify endpoint feeding numeric input to List
  2. Delivery
    Submit index/size value near 2^30
  3. Exploit
    Value reaches setListBounds in List.js
  4. Execution
    Trigger infinite loop or unbounded allocation
  5. Impact
    Process hang or abort (DoS)

Vulnerability Assessment

Weakness
CWE
ASVS 5.0
V15 - Secure Coding and Architecture Integer overflow checks
MITRE ATT&CK

1 technique across 1 tactic: Execution

The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up.

Exploitation Conditions

Exploitation requires that the target application pass an attacker-influenced numeric value in the range 2^30 to 2^31 (approximately 1,073,741,824 to 2,147,483,647) into one of the affected APIs: List#set, List#setSize, List#setIn, List#updateIn, or the functional set/setIn/updateIn. The concrete trigger is the index/size argument reaching setListBounds in src/List.js. Limiting factors: the vulnerable value must reach one of those specific methods, so an application that never forwards untrusted numbers as List indices/sizes is not exploitable; the empty-List infinite-loop variant and the populated-List allocation variant depend on List state; and only availability is affected - there is no data disclosure or code execution. No authentication is modeled in the vendor CVSS (PR:N), but reachability is entirely dependent on non-default application code paths rather than any Immutable.js configuration setting.

Impact

The signals are internally consistent but modest in real-world urgency. The vendor CVSS 4.0 vector (AV:N/AC:L/AT:N/PR:N/UI:N/VC:N/VI:N/VA:H) scores 8.7 (High) driven entirely by the VA:H availability impact - there is no confidentiality or integrity effect. There is no EPSS score, no CISA KEV listing, and no published proof-of-concept in the provided data, so this is a high-CVSS availability bug rather than a confirmed high-real-risk exploited vulnerability. Crucially, exploitability is conditional on application design: because this is a library, an attacker can only reach the flaw if the host application passes attacker-controllable index/size values (e.g. a request parameter used as a List index or size) into the affected APIs. Where that data flow does not exist, real-world risk is near zero despite the 8.7 score. The vendor vector's PR:N/AC:L reflects worst-case library-internal reachability; defenders should treat AC as effectively higher given the specific numeric range and required code path.

Exploit ScenarioDerived

An application uses Immutable.js and passes a user-supplied number - for example a pagination size, array index, or JSON field - into List#setSize or List#set. An attacker submits a value such as 1073741824 (2^30), and on an empty List the process enters an uncatchable infinite loop or, on a populated List, allocates memory until the Node.js process aborts, taking down the service. No authentication is required at the CVSS level and no published PoC is currently available, but the attack is trivial where such a data path exists.

This Week Schedule remediation this week. Why: HIGH severity (CVSS 7.0-8.9).
Patch available 0.3% exploitation probability (EPSS)

Get an e-mail when this CVE is exploited, patched or re-scored. Free account.

Alert me

AnalysisAIv1 – Jul 08, 2026

Denial of service in the Immutable.js JavaScript library (versions before 4.3.9 and 5.1.8) allows attackers who can influence an index or size value to crash or hang a Node.js/browser process. Passing a value between 2^30 and 2^31 to List#set, setSize, setIn, updateIn (or the functional equivalents) drives setListBounds into an uncatchable infinite loop on empty Lists, unbounded memory allocation until process abort on populated Lists, or a silent integer wrap on setSize. No public exploit code has been identified at time of analysis, and the flaw is not on the CISA KEV list; impact is availability-only.

RemediationAI

Upgrade to Vendor-released patch: 4.3.9 (for 4.x deployments) or 5.1.8 (for 5.x deployments); the fixes are in commits a1a1ee412dcaa380ab325196283d06594ffe4b84 and f0bc997d8eb9886aff2236635aa210a95a04304a and are referenced in advisory GHSA-v56q-mh7h-f735. Because this is a transitive dependency in many builds, run npm/yarn dependency resolution (e.g. npm ls immutable, then update lockfiles) to ensure the patched version is actually resolved rather than a cached vulnerable copy. Where immediate upgrade is not possible, add input validation at the application boundary so that any user-influenced value used as a List index or size is bounds-checked and rejected if it reaches or exceeds 2^30 (roughly 1,073,741,824); this is the specific compensating control, with the trade-off that it must be applied at every call site that forwards untrusted numbers into set, setSize, setIn, updateIn, or the functional set/setIn/updateIn helpers, and it does nothing for internally-computed sizes.

Affected VersionsENISA

immutable-js 5.0.0-beta.1, < 5.1.8
immutable-js < 4.3.9

Affected Packages

npm immutable fix: 3.8.4, 4.3.9, 5.1.8
euvd immutable_js fix: 4.3.9
euvd immutable_js_5_0_0_beta_1 fix: 5.1.8

Source: OSV (Open Source Vulnerabilities)

Affects your stack

Affects 3 packages in npm, euvd

Checking this CVE against your own stacks and servers is part of the Basic plan and up.

Technical ContextAI · show details

Immutable.js is a very widely used npm package providing persistent immutable collections (List, Map, Set, etc.) for JavaScript, commonly embedded in React/Redux front ends and Node.js services. The root cause is CWE-190 (Integer Overflow or Wraparound) inside setListBounds in src/List.js: internal index/size arithmetic assumes values stay within the array-safe range, but values in the range 2^30 to 2^31 break the bounds-computation loop and capacity handling. Because JavaScript numbers and the library's internal 32-bit tree-shift math (Lists are backed by a trie of 32-wide nodes) are involved, an out-of-range index either never satisfies the loop's termination condition (infinite loop) or forces the structure to grow node-by-node without bound (memory exhaustion). The affected component is identified in CPE as cpe:2.3:a:immutable-js:immutable-js.

Know when Immutable Js gets its next vulnerability

  • Watch products and get an email when something new is published
  • Check this CVE against your own stack and servers
  • Exploit and PoC references, threat intelligence from 22 sources

No credit card · 7-day full trial

Severity by source

Vendor (GitHub_M) PRIMARY 8.7 HIGH
CVSS:4.0/AV:N/AC:L/AT:N/PR:N/UI:N/VC:N/VI:N/VA:H/SC:N/SI:N/SA:N
vuln.today AI 7.5 HIGH

Availability-only DoS reachable over the network with no auth or interaction when the app forwards untrusted numbers; scope unchanged, no confidentiality or integrity impact.

3.1 AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H
4.0 AV:N/AC:L/AT:N/PR:N/UI:N/VC:N/VI:N/VA:H/SC:N/SI:N/SA:N
SUSE 7.5 HIGH
AV:N/AC:L/PR:N/UI:N/S:U/C:N/I:N/A:H
Red Hat 7.5 MEDIUM

Primary rating from Vendor (GitHub_M).

CVSS VectorVendor: GitHub_M

Attack Vector
Network
Attack Complexity
Low
Attack Requirements
None
Privileges Required
None
User Interaction
None
Vulnerable system: Confidentiality
None
Vulnerable system: Integrity
None
Vulnerable system: Availability
High
Subsequent system: Confidentiality
None
Subsequent system: Integrity
None
Subsequent system: Availability
None

Lifecycle Timeline

1
Patch available
Jul 08, 2026 - 18:02 EUVD

DescriptionCVE.org

Immutable.js provides many Persistent Immutable data structures. Prior to 4.3.9 and 5.1.8, List#set, List#setSize, List#setIn, List#updateIn, and the functional set, setIn, and updateIn mishandle an index or size in the range 2 30 to 2 31 in setListBounds in src/List.js, causing an empty List to enter an uncatchable infinite loop, a populated List to allocate without bound until process abort, or setSize to silently wrap large values. This issue is fixed in versions 4.3.9 and 5.1.8.

Blast Radius

ecosystem impact
† from your stack dependencies † transitive graph · vuln.today resolves 4-path depth
  • 2 npm packages depend on immutable (2 direct, 0 indirect)

Ecosystem-wide dependent count for version 4.0.0-rc.1.

Executive ViewAI

Why It Matters

Immutable.js, a widely-adopted JavaScript data structure library, contains a denial-of-service vulnerability in versions before 4.3.9 and 5.1.8 that allows attackers to crash or hang Node.js and browser processes by providing specially crafted index or size values. Organizations relying on this library for production services face operational risk from service interruptions if untrusted users can influence these parameters. No public exploit identified at time of analysis, but no vendor patch is currently available, requiring immediate interim security controls.

Business Impact: High
Compensating Controls

No vendor-released patch identified at time of analysis. Interim mitigations: (1) implement strict input validation to block index/size values between 2^30 and 2^31; (2) enforce process-level resource limits (memory ceiling, CPU throttling) on all Node.js processes using Immutable.js; (3) deploy request rate limiting on APIs accepting user-influenced index/size parameters; (4) establish continuous monitoring with alerting for process crashes and hangs correlated with suspicious input patterns.

Threat Intelligence Overview

EPSS Score
0.3%
Top 78% exploitable
Prevalence
High
extremely popular npm immutable-data library, common in React/Redux and Node apps
Threat Intel
1
1 sources
Data Quality
7 sources
Confidence: High
EUVD NVD CVE.org EPSS Vulnrichment GHSA Vendor GitHub VulDB

How this decision was reached

The engine reads each signal below and applies a fixed list of rules from top to bottom. The first rule that matches sets the recommended action – like a statement, every line is shown.

SignalValue
Severity HIGH
CISA KEV No
Public POC No
EPSS 0.3%
Patch available Yes
Active threat No
Deciding rule
HIGH severity (CVSS 7.0-8.9)
What every action level means
Emergency Immediate action required. Criteria: CRITICAL + in CISA KEV (actively exploited) without patch, OR CRITICAL + EPSS > 30% without patch, OR CRITICAL + active threat signals without patch.
Act Now Prioritize within 24-48h. Criteria: in KEV with patch available, OR CRITICAL + public POC, OR HIGH + EPSS > 10%, OR CRITICAL + active threat, OR any CRITICAL severity.
This Week Schedule remediation this week. Criteria: HIGH severity (CVSS 7.0-8.9). Patch within normal change window.
This Month Plan within 30 days. Criteria: MEDIUM severity (CVSS 4.0-6.9), lower exploitation probability. Include in regular patch cycle.
Monitor Track and reassess. Criteria: LOW severity (CVSS 0.1-3.9), minimal exploitation risk. No immediate action needed.

SSVC AssessmentENISA

SSVC Decision
Out-of-Cycle
Exploitation
Poc
System Exposure· derived
Open
Automatable
Yes
Human Impact
High
Technical Impact
Partial

Priority Score

44
Low Medium High Critical
KEV: 0
EPSS: 0
CVSS: +44
PoC: 0
Weaponized: 0
Threat intel: 0
Gov advisory: 0

Attack Technique

Integer overflow occurs when an arithmetic operation produces a result that exceeds the maximum value a given integer type can store.

Denial of Service attacks render applications or systems unavailable by overwhelming resources or triggering failure conditions.

Vendor StatusVendor

SUSE

Severity: Important
Product Status
SUSE Linux Enterprise Desktop 15 SP7 Affected
SUSE Linux Enterprise High Performance Computing 12 Not-Affected
SUSE Linux Enterprise Micro 5.3 Not-Affected
SUSE Linux Enterprise Micro 5.3 Not-Affected
SUSE Linux Enterprise Micro 5.3 Not-Affected

This site uses cookies essential for authentication and security. No tracking or analytics cookies are used. Privacy Policy