Skip to main content

i18next CVE-2026-63402

MEDIUM
Modification of Assumed-Immutable Data (MAID) (CWE-471)
2026-10-30 GitHub_M
5.9
CVSS 3.1 · Vendor: GitHub_M
View

Attack ChainAIDerived

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

  1. Access
    Supply crafted translation bundle data
  2. Delivery
    Reach addResourceBundle with deep:true and overwrite:true
  3. Exploit
    deepExtend recurses via 'in' into Object.prototype built-in
  4. Execution
    Overwrite hasOwnProperty.call with non-callable value
  5. Impact
    Process-wide TypeError, unrecoverable denial of service

Vulnerability Assessment

Weakness
CWE
Exploitation Conditions

Exploitation requires the application itself to call addResourceBundle(lng, ns, data, deep, overwrite) with BOTH deep:true AND overwrite:true while passing attacker-controlled resource data; the attacker-supplied source object must contain a key matching an inherited built-in (e.g. hasOwnProperty, toString, valueOf) whose nested value overwrites a property of that shared built-in function (e.g. setting Object.prototype.hasOwnProperty.call non-callable). Strong limiting factors: this is explicitly a non-default configuration - the default addResourceBundle path (no deep merge, or overwrite falsy) is unaffected, and the advisory states no standard i18next backend or integration uses the vulnerable configuration, so exposure is confined to custom application code that deep-merges untrusted translation content. Fixed in 26.3.4, which checks existence with Object.prototype.hasOwnProperty.call instead of the in operator; per the advisory, upgrading is the remediation.

Impact

Signals point to a genuine but conditional, lower-tier risk. The CVSS 3.1 vector (AV:N/AC:H/PR:L/UI:N/S:U/C:N/I:L/A:H, base 5.9 Medium) encodes the core story: network-reachable but high attack complexity (AC:H) because exploitation is gated behind a specific non-default merge configuration, with impact concentrated in availability (A:H, process-wide unrecoverable DoS) plus limited integrity (I:L, a shared built-in set to an attacker value) and no confidentiality impact (C:N). The vuln.today decision label is 'this_month' rather than act_now/emergency, consistent with a flaw that is serious where present but not broadly exploitable. This is NOT a confirmed-exploited emergency: there is no CISA KEV listing and no EPSS score in the supplied data, so widespread exploitation probability cannot be quantified from the input. A working proof-of-concept is published inside the GitHub Security Advisory (GHSA-6jcc-5g8w-32mx), which raises reproducibility but does not equal active exploitation - POC availability and in-the-wild use are distinct signals. The key tension is between the network attack vector and the real-world precondition: AV:N suggests remote reach, but the advisory is explicit that the flaw only triggers when application code deliberately passes attacker-controlled data to addResourceBundle with both deep:true and overwrite:true, and that no standard i18next backend or integration does this. Net assessment: treat as a targeted/conditional issue to remediate on a normal patch cadence (this month), not a high-urgency widespread threat.

Exploit ScenarioDerived

An application exposes a code path that merges externally-supplied translation content into i18next by calling addResourceBundle with deep:true and overwrite:true. An attacker submits a crafted resource bundle such as { hasOwnProperty: { call: 'corrupted' } }, causing deepExtend to recurse into the shared Object.prototype.hasOwnProperty function and overwrite its .call with a non-callable value, so every subsequent hasOwnProperty.call across the process throws TypeError and the service becomes unusable. A working PoC demonstrating exactly this is published in the GHSA advisory; the AC:H rating reflects that the vulnerable deep+overwrite merge of untrusted data is a non-default precondition rather than a difficult trigger once that path exists.

This Month Plan within 30 days. Why: MEDIUM severity (CVSS 4.0-6.9).
No patch listed yet 0.3% exploitation probability (EPSS)

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

Alert me

AnalysisAIv1 – Oct 30, 2026

i18next core versions up to and including 26.3.3 allow process-wide corruption of shared built-in objects such as Object.prototype.hasOwnProperty when an application deep-merges untrusted resource data via addResourceBundle(lng, ns, data, deep, overwrite) with both deep:true and overwrite:true. Supplying a source key that matches an inherited built-in (hasOwnProperty, toString, valueOf) makes deepExtend recurse into that shared function and, with overwrite enabled, set one of its properties to attacker-controlled data - for example making Object.prototype.hasOwnProperty.call non-callable - after which subsequent calls, including i18next's own internals, throw TypeError and the process cannot recover, yielding denial of service with limited integrity impact. The configuration is non-default and no standard i18next backend or integration uses it, so exposure is confined to custom application code that merges attacker-controlled translation content; the CVSS vector scores PR:L with AC:H, and no public exploit identified at time of analysis beyond the proof-of-concept snippet published in the vendor advisory (a public PoC reference exists; it is not verified as working exploit code).

RemediationAI

Vendor-released patch: i18next 26.3.4 - upgrade the npm dependency to 26.3.4 or later, which replaces the in-operator check in deepExtend with Object.prototype.hasOwnProperty.call(target, prop) so inherited keys are copied as plain own data instead of triggering recursion into shared built-ins. Per the advisory, upgrading is the remediation, and release 26.3.4 is available at https://github.com/i18next/i18next/tree/v26.3.4 (advisory: https://github.com/i18next/i18next/security/advisories/GHSA-6jcc-5g8w-32mx, fix commit: https://github.com/i18next/i18next/commit/642137b7786d83661ec3ee53027798dc4b81d30a). Where an upgrade cannot be applied immediately, the exposure is limited to application code that passes attacker-controlled resource objects to addResourceBundle with deep:true and overwrite:true, so removing that combination - dropping deep merging for untrusted bundles, passing overwrite falsy, or filtering/allowlisting top-level resource keys such as hasOwnProperty, toString and valueOf before merging - prevents the corruption, at the cost of losing deep-merge semantics for those bundles; the advisory notes the default non-deep path is unaffected, so falling back to plain bundle registration avoids the issue.

Affects your stack

Find out whether the stacks and servers you run are on an affected version.

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

Technical ContextAI · show details

The flaw lives in src/utils.js of i18next core, in the deepExtend helper reached through the public addResourceBundle API. deepExtend tested key existence against the destination with the in operator, which walks the prototype chain rather than checking own properties; as a result a source key such as hasOwnProperty, toString or valueOf was treated as already present in an empty object because it is inherited from Object.prototype. The function then recursed with the shared built-in function object as the target, and a nested value combined with overwrite:true wrote an own property onto that shared object - the advisory's example sets Object.prototype.hasOwnProperty.call to a string, so every later Object.prototype.hasOwnProperty.call(...) invocation throws TypeError. This maps to CWE-471 (modification of assumed-immutable data), with CWE-1321 (prototype pollution) also cited in the advisory, although the corruption target here is an inherited built-in function rather than the prototype object itself, which is why the existing __proto__/constructor guard did not prevent it. The trigger requires the application to explicitly call addResourceBundle with deep:true and overwrite:true while passing attacker-controlled resource data; default calls without deep merging, or with overwrite falsy, are unaffected. The advisory distinguishes this from CVE-2026-48713 (i18next-fs-backend) and CVE-2026-48714 (i18next-http-middleware), which are setPath/key-walking prototype-pollution issues in different packages.

Know when I18Next 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 5.9 MEDIUM
AV:N/AC:H/PR:L/UI:N/S:U/C:N/I:L/A:H
vuln.today AI 5.9 MEDIUM

AC:H because the vulnerable deep:true+overwrite:true merge of untrusted data is a non-default precondition; A:H for process-wide unrecoverable DoS, I:L for the limited built-in corruption, C:N as no data is disclosed.

3.1 AV:N/AC:H/PR:L/UI:N/S:U/C:N/I:L/A:H
4.0 AV:N/AC:H/AT:N/PR:L/UI:N/VC:N/VI:L/VA:H/SC:N/SI:N/SA:N

Primary rating from Vendor (GitHub_M).

CVSS VectorVendor: GitHub_M

Attack Vector
Network
Attack Complexity
High
Privileges Required
Low
User Interaction
None
Scope
Unchanged
Confidentiality
None
Integrity
Low
Availability
High

DescriptionCVE.org

i18next is an internationalization framework for JavaScript. Prior to version 26.3.4, deepExtend in src/utils.js checks property existence with the in operator and recurses into inherited built-ins reached through Object.prototype. An application must explicitly pass attacker-controlled resource data to addResourceBundle(lng, ns, data, deep, overwrite) with both deep: true and overwrite: true. Source keys such as hasOwnProperty, toString and valueOf can then select shared inherited built-in function objects, and a nested value can overwrite a property of those objects process-wide. For example, making Object.prototype.hasOwnProperty.call non-callable causes subsequent uses, including i18next internals, to throw TypeError, resulting in unrecoverable denial of service and limited integrity impact. The __proto__/constructor guard does not prevent this mechanism because the corruption target is an inherited built-in function rather than the prototype object itself. Default calls without deep merging or with overwrite falsy are unaffected, and no standard i18next backend or integration uses the vulnerable configuration. This issue is distinct from the setPath/key-walking prototype-pollution flaws in i18next-fs-backend (CVE-2026-48713) and i18next-http-middleware (CVE-2026-48714). This issue is fixed in version 26.3.4.

Threat Intelligence Overview

EPSS Score
0.3%
Top 82% exploitable
Prevalence
High
i18next is a very widely deployed JavaScript internationalization library
Social Media
2
Sightings
Data Quality
3 sources
Confidence: Low

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 MEDIUM
CISA KEV No
Public POC No
EPSS 0.3%
Patch available No
Active threat No
Deciding rule
MEDIUM severity (CVSS 4.0-6.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· derived
Scheduled
Exploitation· derived
None
System Exposure· derived
Open
Automatable· derived
No
Human Impact· derived
High

Priority Score

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

Attack Technique

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

Affected Products (CPE)CVE.org

cpe:2.3:a:i18next:i18next:*:*:*:*:*:*:*:*

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