Skip to main content

i18next-fs-backend CVE-2026-41693

| EUVDEUVD-2026-28793 HIGH
External Control of File Name or Path (CWE-73)
2026-05-08 GitHub_M
8.2
CVSS 3.1 · GitHub Advisory
View

Attack ChainAIDerived

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

  1. Access
    Send HTTP request with traversal payload in lng parameter
  2. Delivery
    i18next-http-middleware populates language from query string
  3. Exploit
    Application calls i18next.t() with attacker-controlled lng
  4. Execution
    i18next-fs-backend interpolates lng into loadPath template
  5. Persist
    fs.readFile executes on traversed path
  6. Impact
    Sensitive 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.

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

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

Alert me

AnalysisAIv1 – 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

i18next-fs-backend < 2.6.4

Affected Packages

npm i18next-fs-backend fix: 2.6.4

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

GitHub Advisory PRIMARY 8.2 HIGH
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

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

Lifecycle Timeline

2
Patch available
May 08, 2026 - 17:02 EUVD
CVE Published
May 08, 2026 - 15:38 nvd
HIGH 8.2

DescriptionGitHub 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.

Executive ViewAI

Why It Matters

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.

Business Impact: Severe
Compensating Controls

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

EPSS Score
0.0%
Top 88% exploitable
Data Quality
5 sources
Confidence: Medium

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.0%
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
None
System Exposure· derived
Open
Automatable
Yes
Human Impact
Very High
Technical Impact
Partial

Priority Score

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

Attack Technique

Information disclosure occurs when an application unintentionally exposes sensitive data that aids attackers in reconnaissance or directly compromises security.

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