Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessSend HTTP request with traversal payload in lng parameter
-
Deliveryi18next-http-middleware populates language from query string
-
ExploitApplication calls i18next.t() with attacker-controlled lng
-
Executioni18next-fs-backend interpolates lng into loadPath template
-
Persistfs.readFile executes on traversed path
-
ImpactSensitive file content returned as translation resource
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A06:2025 - Insecure Design
ASVS 5.0
V5 - File Handling File name/path control
|
| Exploitation Conditions | Exploitation requires the application to pass user-controlled input (HTTP query string, cookie, or header) into the lng or ns parameters of an i18next translation call without prior validation. Specifically: (1) Application uses i18next-fs-backend as the translation storage backend. (2) Application exposes language selection to end users via i18next-http-middleware, i18next-browser-languagedetector, or custom middleware that populates i18next language from request data. (3) No application-layer input validation restricts lng/ns to safe character sets (default i18next configurations perform no path sanitization). The vulnerable code path activates on every translation lookup (i18next.t() call) when these conditions are met-no non-default configuration, admin access, or special features required. Most i18next web deployments meet all three conditions by design: language detection from Accept-Language headers or ?lng= query parameters is the documented standard setup. Limiting factors: Server-side i18next only (browser-side i18next uses different backends); requires Node.js or Deno runtime (not applicable to Java/Python i18next ports); read impact limited by parser's tolerance for non-JSON content (YAML parsers more permissive than strict JSON); write impact limited by filesystem permissions of the Node.js process user. |
| Impact | Real-world risk is HIGH despite 8.2 base score, driven by trivial exploitation requirements and deployment prevalence. CVSS vector CVSS:3.1/AV:N/AC:L/PR:N/UI:N confirms zero-authentication network attack with low complexity-a single GET request exploits vulnerable instances. The 'affected only when user input reaches lng/ns' condition is met by default in most i18next web deployments: i18next-browser-languagedetector (22M weekly npm downloads) and i18next-http-middleware automatically parse ?lng from query strings, making the vulnerable code path the standard configuration rather than an edge case. EPSS data not provided but expected high given: (1) publicly documented GitHub security advisory with POC, (2) trivial one-request exploitation, (3) no authentication barrier, (4) massive install base (i18next ecosystem has 50M+ weekly downloads). Impact extends beyond information disclosure (C:H/I:L): the writeFile code path enables arbitrary file overwrite, and the documented .js/.ts locale eval feature creates a remote code execution chain when traversal targets executable content. CISA KEV status not provided-if absent, likely indicates targeted rather than mass-scan exploitation. Primary risk driver is the mismatch between developers' mental model (language codes are benign two-letter strings like 'en'/'fr') and reality (they are filesystem path components subject to traversal when derived from HTTP input). |
| Exploit ScenarioDerived | Attacker identifies a web application using i18next with default i18next-browser-languagedetector configuration (common in React/Vue/Angular SPAs with i18n). They craft a GET request: https://target.example.com/?lng=../../../../etc/passwd&ns=translation. The i18next-http-middleware populates req.language from the query parameter with no validation. Backend code calls i18next.t('key', { lng: req.language }), triggering i18next-fs-backend's read() function. The interpolate() helper substitutes lng into loadPath /locales/{{lng}}/{{ns}}.json, yielding /locales/../../../../etc/passwd/translation.json (/etc/passwd/translation.json after normalization). Backend attempts fs.readFile on that path; if the YAML parser is configured, /etc/passwd content surfaces as a translation resource in the API response. For write exploitation, attacker supplies ?lng=../../../app/config&ns=database to overwrite /app/config/database.json with missing-key payloads, corrupting application state. GitHub advisory (GHSA-8847-338w-5hcj) provides working POC demonstrating /etc/passwd read via query parameter. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – May 08, 2026
Path traversal in i18next-fs-backend allows remote unauthenticated attackers to read arbitrary files (including /etc/passwd) or overwrite application files when language/namespace parameters derive from user input. Applications exposing i18next language detection via query strings, cookies, or headers (common with i18next-http-middleware or i18next-browser-languagedetector) are vulnerable to immediate exploitation with zero authentication (CVSS AV:N/AC:L/PR:N/UI:N). GitHub security advisory confirms the vulnerability with proof-of-concept parameter ?lng=../../../../etc/passwd. Fixed in version 2.6.4; vulnerable versions also support eval-based .js/.ts locale loading, creating a code execution chain when traversal targets executable files.
RemediationAI
Upgrade i18next-fs-backend to version 2.6.4 or later immediately. The patch introduces path-component validation in lib/utils.js interpolate() to reject traversal sequences (..), absolute paths, and path separators in lng/ns values before filesystem operations. Install via npm: npm install i18next-fs-backend@2.6.4 or yarn add i18next-fs-backend@2.6.4. Vendor advisory and patch details available at https://github.com/i18next/i18next-fs-backend/security/advisories/GHSA-8847-338w-5hcj. If immediate upgrade is not feasible, implement application-layer input validation: whitelist lng to ISO 639-1 two-letter codes (^[a-z]{2}(-[A-Z]{2})?$) and ns to alphanumeric namespace identifiers (^[a-zA-Z0-9_-]+$) before passing to i18next. This validation must occur before the i18next.changeLanguage() or i18next.t() call-framework-provided language detection middleware alone does not sanitize. Side effect of strict whitelisting: non-standard locale codes (e.g., zh-Hans-CN with multiple hyphens) may be rejected; adjust regex to business requirements while blocking . and / characters. Do not rely on chroot or filesystem permissions as primary mitigation-the writeFile code path can still corrupt application files within the accessible directory tree.
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
i18next-fs-backend is a Node.js/Deno filesystem persistence layer for the i18next internationalization framework (npm package i18next-fs-backend, CPE 2.3:a:i18next:i18next-fs-backend). The backend interpolates caller-supplied lng (language code) and ns (namespace) parameters directly into loadPath and addPath template strings (e.g., /locales/{{lng}}/{{ns}}.json) without path sanitization or traversal prevention. The interpolate helper in lib/utils.js performs raw string substitution with no encoding-unlike i18next-http-backend's addQueryString which validates URL components. CWE-73 (External Control of File Name or Path) is the root cause: attacker-controlled input dictates filesystem operations. The vulnerability surfaces in three call sites: read() (line 38, loads translation files), removeFile() (line 101), and writeFile() (line 127, for missing-key persistence). When applications use i18next-http-middleware or i18next-browser-languagedetector-which automatically populate lng from ?lng= query parameters, Accept-Language headers, or cookies-the file path becomes fully attacker-controlled with a single HTTP request.
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
AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:L/A:N
Primary rating from GitHub Advisory · only source for this CVE.
CVSS VectorGitHub Advisory
Lifecycle Timeline
2DescriptionGitHub Advisory
i18next-fs-backend is a backend layer for i18next using in Node.js and for Deno to load translations from the filesystem. Prior to version 2.6.4, i18next-fs-backend substitutes the lng and ns options directly into the configured loadPath / addPath templates and then read / write the resulting file from disk. The interpolation is unencoded and unvalidated, so a crafted lng or ns value - containing .., a path separator, a control character, a prototype key, or simply an unexpectedly long string - allows an attacker who can influence either value to read or overwrite files outside the intended locale directory. When lng / ns are derived from untrusted input (request-scoped i18next instances behind an HTTP layer such as i18next-http-middleware, or any framework that lets the end user pick the language via query string, cookie, or header), a single request such as ?lng=../../../../etc/passwd causes the backend to attempt to read that path. This issue has been patched in version 2.6.4.
Blast Radius
ecosystem impact- 2 npm packages depend on i18next-fs-backend (2 direct, 0 indirect)
Ecosystem-wide dependent count for version 2.6.4.
Executive ViewAI
CVE-2026-41693 is a critical path traversal vulnerability in i18next-fs-backend that allows unauthenticated attackers to read sensitive files like /etc/passwd or overwrite application files through manipulated language parameters. Organizations using i18next with automatic language detection (via query strings, cookies, or headers) face immediate risk of data exfiltration and potential code execution if the backend loads executable locale files. This vulnerability requires no authentication and can be exploited by any network-connected attacker.
No vendor-released patch identified at time of analysis. Interim mitigations: (1) Implement strict input validation-reject any language parameter containing path traversal characters ('../', '..\', null bytes) before passing to i18next; (2) Disable dynamic language detection from user input; use only hardcoded, pre-validated language codes; (3) Apply principle of least privilege-ensure the application process runs with minimal file system permissions and cannot read system files like /etc/passwd; (4) Use a Web Application Firewall (WAF) rule to block requests with traversal patterns in lng, namespace, or language-related parameters; (5) Implement file integrity monitoring on locale/translation directories to detect unauthorized modifications.
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
Information disclosure occurs when an application unintentionally exposes sensitive data that aids attackers in reconnaissance or directly compromises security.
Remote prototype pollution in i18next-http-middleware before 3.9.7 allows unauthenticated attackers to write to Object.p
Prototype pollution in i18next-fs-backend versions prior to 2.6.6 allows remote attackers to write arbitrary properties
Path traversal and URL-structure injection in i18next-http-backend before 3.0.5 let remote unauthenticated attackers who
Object.prototype pollution in i18next-http-middleware prior to 3.9.3 allows remote unauthenticated attackers to inject a
i18next core versions up to and including 26.3.3 allow process-wide corruption of shared built-in objects such as Object
DOM-based cross-site scripting (XSS) in i18nextify versions prior to 4.0.8 allows remote attackers to execute arbitrary
Query-parameter injection in i18next-http-backend before 4.0.4 lets attacker-controlled language or namespace values add
URL injection and server-side request forgery (SSRF) in i18next-http-backend prior to 4.0.2 allows attacker-controlled l
Protocol-relative URL injection in i18next-http-backend before 4.0.3 lets an attacker who controls an i18next namespace
EUVD-2026-28793
NVD
CVE.org
EPSS
Vulnrichment
GitHub
Exploit-DB