Nov 20, 2026·10 min read·1 visit
Etherpad versions 1.8.14 through 3.3.2 contain an unauthenticated path traversal flaw (CVSS 9.8) in `src/node/utils/Minify.ts`. By submitting URL-encoded backslashes (`..%5C`) to the `/static/*` endpoint on POSIX hosts, attackers bypass path sanitization and can read arbitrary files such as `settings.json`, leading to administrative takeover and remote code execution. Upgrade to version 3.3.3.
A pre-authentication path traversal vulnerability exists in Etherpad versions 1.8.14 prior to 3.3.3 within the `/static/*` plugin asset handler. In `src/node/utils/Minify.ts`, an unconditional backslash-to-forward-slash conversion is executed after pathname sanitization has already concluded. On POSIX systems, this transforms benign backslash characters into directory traversal sequences (`../`), allowing unauthenticated remote attackers to read arbitrary files from the host filesystem, extract administrative credentials from `settings.json`, and achieve remote code execution via the plugin installation interface.
Etherpad is an open-source, real-time collaborative document editor built on Node.js. To deliver client-side JavaScript, stylesheets, and plugin resources, Etherpad exposes a static asset routing layer under the /static/* URI prefix. This routing logic is implemented within src/node/utils/Minify.ts and handles both core application assets and third-party or built-in plugin directories.
Crucially, the /static/* route handler is registered during the expressPreSession lifecycle hook. Because expressPreSession executes prior to session initialization and authentication middleware, all endpoints registered at this stage are publicly accessible to unauthenticated network clients. Furthermore, Etherpad installs the core pseudo-plugin ep_etherpad-lite by default, ensuring that the plugin asset resolution code path in Minify.ts is active on every standard deployment.
Tracked as CVE-2026-114516 (and GitHub Security Advisory GHSA-mc8w-wjhw-45x5), a path traversal vulnerability classified under CWE-22 exists in how Minify.ts normalizes file paths after initial validation. In versions starting from 1.8.14 and prior to 3.3.3, a mismatch between POSIX pathname sanitization and post-sanitization character replacement allows unauthenticated attackers to escape the intended static asset root directory.
Successful exploitation permits an unauthenticated remote attacker to read arbitrary files accessible to the Node.js process on POSIX systems. When chained with the retrieval of application configuration files such as settings.json or process memory artifacts via /proc/self/environ, an attacker can extract plain-text administrative credentials or session secrets. These credentials grant access to the /admin/plugins interface, enabling arbitrary Node.js package installation and full in-process remote code execution.
The root cause of CVE-2026-114516 is a Time-of-Check to Time-of-Use (TOCTOU) state discrepancy between the path sanitizer (src/node/utils/sanitizePathname.ts) and the asset resolver (src/node/utils/Minify.ts). In secure file server implementations, any character normalization or separator canonicalization must occur strictly prior to path traversal validation. In vulnerable versions of Etherpad, separator transformation is performed after sanitization has already completed.
When an HTTP request arrives at /static/*, the requested relative path is passed to sanitizePathname(). This module enforces path containment based on the semantics of the underlying operating system. On POSIX platforms (such as Linux and macOS), the forward slash (/) is the sole directory separator, whereas the backslash (\) is treated by the kernel and the Node.js path.posix implementation as an ordinary filename byte. Consequently, if a request contains URL-encoded backslashes (%5C) forming ..\..\, sanitizePathname() decodes the URI and inspects the segments. Because ..\ does not contain a forward slash, the sanitizer evaluates it as a single literal filename rather than a parent directory reference (..) and permits the string to pass unchanged.
After sanitizePathname() returns the validated string, Minify.ts resolves the target plugin's base path and joins it with the user-supplied relative path using path.join(pluginPath, libraryPath). Immediately following this operation, Minify.ts executes an unconditional regular expression replacement: filename = filename.replace(/\\/g, '/'). This line was originally introduced in commit 571b37b772c324d6f5eddcd3aecf3e02ffcac1c3 to normalize Windows backslashes produced by Node.js path utilities into forward slashes expected by downstream helpers.
Because this replacement was not restricted to Windows hosts (path.sep === '\\'), executing it on a POSIX host mutates the previously inert backslash characters into active POSIX path separators (/). The literal string ..\..\ is transformed into ../../ after all security checks have concluded. No subsequent canonicalization or prefix verification (such as verifying that path.resolve(filename) begins with pluginPath) is performed before passing filename to filesystem read operations.
The vulnerability resides in the _minify function within src/node/utils/Minify.ts. When a request matches the plugin static file pattern (such as plugins/ep_etherpad-lite/static/*), the handler extracts the target plugin name (library) and the relative asset path (libraryPath), joins them, and normalizes path separators.
In versions prior to 3.3.3, the developers included a code comment explicitly assuming that converting backslashes to forward slashes was safe because sanitizePathname had allegedly stripped ..\ substrings. That assumption held true on Windows—where path.win32 treats \ as a separator during sanitization—but failed on POSIX environments.
// Vulnerable code in src/node/utils/Minify.ts (prior to 3.3.3)
const plugin = plugins.plugins[library];
const pluginPath = plugin.package.realPath;
filename = path.join(pluginPath, libraryPath);
// On Windows, path.relative converts forward slashes to backslashes. Convert them back
// because some of the code below assumes forward slashes. Node.js treats both the backlash
// and the forward slash characters as pathname component separators on Windows so this does
// not change the meaning of the pathname. This conversion does not introduce a directory
// traversal vulnerability because all '..\\' substrings have already been removed by
// sanitizePathname.
filename = filename.replace(/\\/g, '/');Commit 9c8d16d50e2fdfd9693ab35c43280410cb4db2fc remediates the flaw by guarding the .replace(/\\/g, '/') call behind an explicit check against the runtime platform's path separator (if (path.sep === '\\')).
--- a/src/node/utils/Minify.ts
+++ b/src/node/utils/Minify.ts
@@ -177,13 +177,18 @@ const _minify = async (req:any, res:any) => {
const plugin = plugins.plugins[library];
const pluginPath = plugin.package.realPath;
filename = path.join(pluginPath, libraryPath);
- // On Windows, path.relative converts forward slashes to backslashes. Convert them back
- // because some of the code below assumes forward slashes. Node.js treats both the backlash
- // and the forward slash characters as pathname component separators on Windows so this does
- // not change the meaning of the pathname. This conversion does not introduce a directory
- // traversal vulnerability because all '..\\' substrings have already been removed by
- // sanitizePathname.
- filename = filename.replace(/\\/g, '/');
+ // On Windows, path.join converts forward slashes to backslashes. Convert them back because
+ // some of the code below assumes forward slashes. Node.js treats both the backslash and the
+ // forward slash characters as pathname component separators on Windows so this does not
+ // change the meaning of the pathname on Windows.
+ //
+ // THIS CONVERSION MUST ONLY BE DONE ON WINDOWS. On POSIX systems a backslash is an ordinary
+ // filename byte, not a separator, so sanitizePathname() deliberately leaves '..\\' segments
+ // untouched (they are harmless there). Replacing '\\' with '/' unconditionally would turn
+ // those already-sanitized bytes back into '../' path components *after* the traversal check
+ // has run, reintroducing a directory-traversal / arbitrary-file-read vulnerability
+ // (GHSA-mc8w-wjhw-45x5).
+ if (path.sep === '\\') filename = filename.replace(/\\/g, '/');
} else if (LIBRARY_WHITELIST.indexOf(library) !== -1) {With this patch applied, path.sep evaluates to '/' on POSIX platforms, skipping the replacement entirely. Consequently, any ..\ sequence remains a literal filename containing backslashes. When Node.js attempts to look up the literal file .../static/..\..\etc/passwd on the filesystem, the file does not exist and the server returns an HTTP 404 Not Found response.
Evaluating fix completeness, guarding the separator replacement eliminates the post-sanitization mutation vector in Minify.ts. However, relying solely on pre-normalization input filters without enforcing a post-resolution canonical prefix check (e.g., verifying fs.realpath or path.resolve against the base directory) leaves little defense-in-depth if additional string transformations are introduced in the future. Within the current architecture of Minify.ts, no other post-sanitization separator transformations occur on the filename variable, making the fix effective against this attack vector.
Exploiting CVE-2026-114516 requires network access to the HTTP/HTTPS interface of an Etherpad instance running on a POSIX host (such as Linux, FreeBSD, or macOS). No authentication tokens, session cookies, or valid pad identifiers are needed because the /static/* router sits in front of the session handler via expressPreSession.
To construct a working payload, the attacker targets the built-in ep_etherpad-lite pseudo-plugin path /static/plugins/ep_etherpad-lite/static/. The attacker appends multiple ..%5C segments sufficient to traverse all the way back to the filesystem root directory (/). Note that standard forward slashes (/ or %2F) cannot be used inside the traversal sequence (..%2F), as sanitizePathname.ts decodes %2F and strips .. components before Minify.ts is reached. Only %5C (encoded backslash) survives sanitization on POSIX and gets converted into / by Minify.ts.
GET /static/plugins/ep_etherpad-lite/static/..%5C..%5C..%5C..%5C..%5C..%5C..%5C..%5C..%5C..%5Cetc/passwd HTTP/1.1
Host: target.etherpad.local
User-Agent: Mozilla/5.0
Accept: */*
Connection: closeWhen the server processes this request, excess ../ components at the root directory (/) resolve to / itself, making a traversal depth of 10 or more segments agnostic to the installation directory depth. The server responds with HTTP 200 OK and streams the contents of /etc/passwd in the response body.
To escalate from arbitrary file read to remote code execution on a Linux target, the attacker does not need to guess the installation directory of Etherpad. Instead, the attacker references the procfs symlink /proc/self/cwd, which always points to the current working directory of the running Node.js process:
GET /static/plugins/ep_etherpad-lite/static/..%5C..%5C..%5C..%5C..%5C..%5C..%5C..%5C..%5C..%5Cproc/self/cwd/settings.json HTTP/1.1
Host: target.etherpad.local
User-Agent: Mozilla/5.0
Accept: */*
Connection: closeBy reading /proc/self/cwd/settings.json (and optionally /proc/self/environ for environment-injected secrets), the attacker obtains the administrative credentials defined under the users configuration block, database connection strings (dbSettings), and the sessionKey. The attacker then authenticates to the /admin portal and uses the plugin manager (/admin/plugins) to install an attacker-controlled npm package, achieving arbitrary code execution within the Node.js runtime.
CVE-2026-114516 carries a CVSS v3.1 base score of 9.8 (CRITICAL) with the vector string CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H. The exploitability metrics reflect the lowest possible barrier to entry: the attack vector is Network (AV:N), attack complexity is Low (AC:L), no privileges are required (PR:N), and no user interaction is necessary (UI:N).
The confidentiality impact is High (C:H). The attacker gains read access to every file on the filesystem that the Etherpad OS user account has permissions to read. This directly exposes application configuration files (settings.json, APIKEY.txt), environment variables (/proc/self/environ), private TLS keys, SSH keys stored in the service user's home directory, and local SQLite database files if SQLite is configured as the backend.
The integrity and availability impacts are also rated High (I:H, A:H). Because Etherpad stores user and administrator credentials inside settings.json and exposes an administrative plugin installer capable of loading arbitrary Node.js modules into the main process, arbitrary file disclosure directly compromises the integrity of the application and underlying server. Furthermore, disclosure of APIKEY.txt allows an unauthenticated attacker to invoke the Etherpad HTTP API with full privileges to modify, read, or delete all collaborative pads on the server.
> [!NOTE]
> Windows deployments of Etherpad are not vulnerable to CVE-2026-114516. On Windows, path.sep is '\\', meaning sanitizePathname.ts already recognizes \ as a directory separator and strips ..\ traversal sequences before Minify.ts executes.
Administrators running affected versions of Etherpad (>= 1.8.14 and < 3.3.3) must upgrade to version 3.3.3 or later. The patch in commit 9c8d16d50e2fdfd9693ab35c43280410cb4db2fc ensures that backslash-to-forward-slash normalization in src/node/utils/Minify.ts is strictly confined to Windows environments.
For standard Git-based deployments, apply the update and rebuild the TypeScript assets using the following commands:
git fetch --tags
git checkout v3.3.3
pnpm i
pnpm run build:etherpadIf an immediate upgrade cannot be performed, operators must implement filtering at a reverse proxy (such as Nginx, Apache, or Caddy) or Web Application Firewall (WAF) positioned in front of the Etherpad service. Requests containing literal backslashes (\) or URL-encoded backslashes (%5c / %5C) within the URI—particularly under /static/—must be rejected before reaching the Node.js backend.
# Nginx mitigation block for CVE-2026-114516
if ($request_uri ~* "(\\|%5c)") {
return 403;
}
location ~* ^/static/.*(\.\./|\.\.\\|\.\.%5c) {
return 403;
}In addition to patching or applying proxy rules, security teams should inspect historical HTTP access logs for GET requests to /static/* containing %5C or %5c that returned HTTP 200 status codes. If evidence of exploitation is identified, assume full compromise of all secrets accessible to the service user: rotate all passwords in settings.json, regenerate APIKEY.txt, rotate database credentials, and audit the node_modules directory for unauthorized plugins.
CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H| Product | Affected Versions | Fixed Version |
|---|---|---|
Etherpad (ep_etherpad-lite) ether | >= 1.8.14, < 3.3.3 | 3.3.3 |
| Attribute | Detail |
|---|---|
| CVE / Advisory ID | CVE-2026-114516 / GHSA-mc8w-wjhw-45x5 |
| Primary Weakness | CWE-22: Improper Limitation of a Pathname to a Restricted Directory ('Path Traversal') |
| CVSS v3.1 Score | 9.8 Critical (CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H) |
| Attack Vector | Unauthenticated Network HTTP GET request to /static/plugins/ep_etherpad-lite/static/* |
| Affected Versions | Etherpad >= 1.8.14, < 3.3.3 (POSIX deployments) |
| Patched Version | Etherpad 3.3.3 (Commit 9c8d16d50e2fdfd9693ab35c43280410cb4db2fc) |
| Impact | Arbitrary File Read leading to Credential Disclosure and Remote Code Execution |
| CISA KEV Status | Not Listed |
The product uses external input to construct a pathname that is intended to identify a file or directory that is located underneath a restricted parent directory, but the product does not properly neutralize special elements within the pathname that can cause the pathname to resolve to a location that is outside of the restricted directory.
A local sandbox escape vulnerability exists in the Natural Language Toolkit (NLTK) versions 3.9.4 through 3.10.3 within its ZIP archive extraction implementation. Due to a type mismatch in member resolution and a failure to inspect filesystem link counts (st_nlink > 1), the extraction routine follows pre-planted hardlinks inside the extraction root, allowing a local attacker to truncate and overwrite arbitrary out-of-root files writable by the executing process.
CVE-2026-129304 is an improper input validation and Redis glob pattern injection vulnerability in Guard Core versions 1.0.0 through 3.12.0. The header parsing routine _extract_from_forwarded_header() extracts values from the X-Forwarded-For HTTP header without verifying that the extracted substring is a valid IPv4 or IPv6 address. In deployments configured with trusted_proxies where the target header index is client-controllable, arbitrary strings containing Redis glob metacharacters reach BehaviorTracker and are interpolated directly into Redis key names and blocking KEYS queries. This allows unauthenticated attackers to aggregate cross-client behavioral metrics, trigger false-positive rate limits, cause denial of service via O(N) Redis keyspace scans, or raise unhandled ValueError exceptions during automated IP ban operations.
iSponsorBlockTV prior to version 2.11.0 contains a blind Server-Side Request Forgery (SSRF) vulnerability in its Simple Service Discovery Protocol (SSDP) and Discovery and Launch (DIAL) client implementation. During local device discovery, the application processes SSDP responses without validating that the URL specified in the LOCATION header or the subsequent application-url response header matches the IP address of the responding UDP host. An adjacent network attacker can spoof SSDP responses to induce the iSponsorBlockTV host to send arbitrary HTTP GET requests and constrained HTTP POST requests to internal network endpoints or loopback services.
CVE-2026-121707 is a high-severity Regular Expression Denial of Service (ReDoS) vulnerability in the Effect TypeScript library prior to version 3.22.1. When evaluating untrusted input against Schema.TemplateLiteral definitions containing multiple string spans, the dynamically compiled regular expression exhibits polynomial backtracking complexity. Because JavaScript runtimes execute on a single-threaded event loop, processing specially crafted non-matching strings causes synchronous CPU starvation and complete application unresponsiveness.
CVE-2026-75518 is an incorrect authorization and privilege assignment vulnerability in the DOMShell Model Context Protocol (MCP) server (@apireno/domshell) prior to version 2.0.8. The server classified the domshell_eval tool and the eval command as read-tier operations, permitting their execution without the --allow-write flag. Because the eval command dispatches through the same Chrome DevTools Protocol (CDP) Runtime.evaluate pipeline as the write-tier js command without enabling the throwOnSideEffect constraint, callers restricted to read-only sessions can execute state-mutating JavaScript in the browser context while host user interfaces and audit logs record the activity as read-only.
CVE-2026-63411 (GHSA-xwcw-j52r-34x4) is a remote code execution vulnerability in the Jane PHP code generation framework (janephp/janephp), specifically affecting the jane-php/open-api-3 component prior to version 7.12.0. The generator constructs PHP docblocks using unsanitized parameter names and descriptions extracted directly from OpenAPI specifications. By embedding the comment closing sequence (*/) followed by valid PHP syntax inside an OpenAPI description or parameter name, an attacker can break out of the PHPDoc context and inject executable code directly into the generated class body. When the consuming application instantiates the generated client or endpoint class, an injected __construct() method executes arbitrary PHP code under the privileges of the host runtime.