CVE-2026-84316 is an improper input validation vulnerability in 0xJacky's nginx-ui that allows authenticated users to bypass directive validation by placing blocked directives after a semicolon on the same line. This bypass affects all guarded write paths that call the validator, enabling injection of dangerous nginx directives such as js_import, load_module, and user root. On deployments with njs or perl modules enabled, this leads to code execution in the nginx worker process, potentially as root. The vulnerability requires authentication via node secret or user JWT and has been demonstrated on version 2.3.11 of the official Docker image. The issue stems from the validator splitting config content by newlines and only inspecting the first token per line, while nginx parses multiple directives separated by semicolons on the same line.
N3.js versions before 2.11.1 have a regular expression denial of service (ReDoS) vulnerability in the N3Lexer number pattern. This flaw causes quadratic backtracking on long digit sequences that do not terminate a number, allowing attackers to supply crafted Turtle or N3 input that blocks the Node.js event loop and results in denial of service.
The nested-lib npm package versions 1.0.0, 1.0.1, and 1.1.0 contain malicious code that sends system information to an unauthorized external server without user consent. The package executes a beacon script both during installation and when required, transmitting hostname, directory paths, and Node.js version over unencrypted HTTP to a hardcoded IP address. The package itself provides no real functionality, acting as a reconnaissance beacon likely used to confirm successful installation before further malicious activity.
The npm package nitro-bundled-dep version 99.0.1 contains malicious code that executes during installation and module import. It collects system information such as hostname, installation path, current working directory, and Node.js version, then sends this data via an unencrypted HTTP POST to a hardcoded IP address unrelated to the package's stated purpose. This behavior resembles a dependency confusion attack, where an internal package name is resolved to a malicious public package with a high version number, enabling reconnaissance on the host system.
## 1. Vulnerability Summary
nginx-ui's `Node.Secret` is a master credential that bypasses all JWT/password authentication for the entire API. The application accepts this credential via a **URL query parameter** (`?node_secret=`), causing it to be recorded in plaintext in HTTP access logs, reverse proxy logs, browser history, and HTTP `Referer` headers. Additionally, the official cluster configuration format embeds node secrets directly into URL query strings stored in `app.ini` and environment variables, creating a systemic credential exposure pattern across the entire cluster deployment model.
An attacker who gains read access to any log aggregation system, proxy log, or configuration file can extract the node secret and obtain full, persistent, unauthenticated administrative access to the nginx-ui API — including reading TLS private keys, modifying nginx configurations, and (when chained with Bug #1) achieving OS-level code execution.
---
## 2. Root Cause Analysis
### 2.1 Node Secret Accepted as URL Query Parameter
The `getNodeSecret` function reads the credential from the URL query string as a fallback when the `X-Node-Secret` header is absent: [1](#3-0)
This function is called in both `AuthRequired()` and `AuthRequiredWS()` middleware, meaning the query parameter bypass works for **all authenticated HTTP and WebSocket endpoints**: [2](#3-1) [3](#3-2)
The same pattern is repeated in the WebSocket origin checker, which also reads `node_secret` from the URL: [4](#3-3)
### 2.2 Node Secret Is a Full Authentication Bypass
The documentation explicitly states this is by design: [5](#3-4)
When the secret matches, the middleware sets the request context to an admin-level init user and calls `c.Next()` — bypassing all JWT validation, session checks, and 2FA: [2](#3-1)
### 2.3 Cluster Configuration Embeds Node Secrets in URLs
The official cluster configuration format, documented and used in `app.example.ini`, stores node secrets as URL query parameters: [6](#3-5)
The `parseNodeUrl` function extracts the secret from the URL's query string and stores it in the database as the node's `Token` field: [7](#3-6)
This means node secrets are embedded in:
- `app.ini` on disk (readable by any process with filesystem access)
- The `NGINX_UI_CLUSTER_NODE` environment variable (visible in `ps aux`, Docker inspect, Kubernetes pod specs, CI/CD logs)
- The SQLite database `nodes` table as the `token` column in plaintext
### 2.4 Node Secret Generation Uses UUID
The secret is auto-generated as a UUID v4 if not set: [8](#3-7)
UUID v4 has 122 bits of entropy, which is adequate. However, the exposure surface described in this report makes entropy irrelevant — the secret is leaked through operational channels, not brute-forced.
---
## 3. Exposure Surface
The following table maps each exposure vector to its source in the codebase:
| Vector | How It Happens | Who Can See It |
|---|---|---|
| **HTTP access logs** | `GET /api/settings?node_secret=xxx` logged by nginx/caddy/apache | Log readers, SIEM operators |
| **Application logs** | Gin debug mode logs full request URLs | Server operators, log aggregators |
| **Browser history** | Admin uses `?node_secret=` URL directly | Anyone with browser access |
| **HTTP Referer header** | Page with `?node_secret=` in URL links to external resource | Third-party servers |
| **WebSocket URL logs** | `ws://host/api/ws?node_secret=xxx` logged by proxies | Proxy log readers |
| **`app.ini` on disk** | Cluster node URLs contain `node_secret=` | Filesystem readers |
| **Environment variables** | `NGINX_UI_CLUSTER_NODE=...&node_secret=...` | `ps aux`, Docker inspect, K8s pod specs |
| **CI/CD pipeline logs** | Env vars printed during deployment | CI/CD log viewers |
| **Database** | `nodes.token` column stored in plaintext SQLite | DB file readers |
---
## 4. Proof of Concept
### Scenario A: Log-Based Secret Extraction
**Step 1 — Attacker gains read access to nginx access logs** (e.g., via a misconfigured log aggregator, a compromised monitoring account, or a separate vulnerability).
**Step 2 — Search logs for the pattern:**
```bash
grep -oP 'node_secret=[^&\s"]+' /var/log/nginx/access.log
# Output: node_secret=a1b2c3d4-e5f6-7890-abcd-ef1234567890
```
**Step 3 — Use the extracted secret for full API access:**
```http
GET /api/settings HTTP/1.1
Host: target:9000
X-Node-Secret: a1b2c3d4-e5f6-7890-abcd-ef1234567890
```
Response: Full settings JSON including `JwtSecret`, `NodeSecret`, all nginx paths, and all configured credentials.
```http
GET /api/nginx/config?filepath=/etc/nginx/nginx.conf HTTP/1.1
Host: target:9000
X-Node-Secret: a1b2c3d4-e5f6-7890-abcd-ef1234567890
```
Response: Full nginx configuration including any embedded credentials.
### Scenario B: Environment Variable Exposure in Docker/Kubernetes
**Step 1 — Attacker reads a Kubernetes pod spec or Docker Compose file:**
```yaml
environment:
- NGINX_UI_CLUSTER_NODE=http://10.0.0.1:9000?name=node1&node_se
A vulnerability in Borewit music-metadata versions before 11.15.0 causes an unhandled exception leading to a process crash. The issue arises from an un-awaited asynchronous call when skipping unrecognized chunks in DSF audio files, which can result in a negative argument passed to a function that throws a RangeError. This error occurs after the main parsing promise resolves, making it uncatchable by typical try/catch error handling. The impact is a denial-of-service (DoS) condition where a single crafted DSF file can crash the Node.js process using music-metadata, affecting availability.
A resource consumption vulnerability exists in Borewit's music-metadata library prior to version 11.16.0. The flaw occurs in the MP4 stsd sample-description parser where an attacker can craft an MP4 input with a zero sample-entry size and a controlled entry_count, causing an infinite synchronous loop. This leads to blocking the Node.js event loop and potentially exhausting system memory. The issue was introduced after version 11.14.0 and fixed in version 11.16.0.
A vulnerability in Borewit's music-metadata prior to version 11.16.0 allows an attacker to cause excessive memory allocation by manipulating the length of VINT elements in Matroska and WebM EBML parsers. This can lead to out-of-memory denial of service or a fatal abort in Node.js 26.7.0. The issue is fixed in version 11.16.0.
MariaDB Connector/Node.js versions prior to 3.2.5, 3.3.4, 3.4.7, and 3.5.4 contain a SQL injection vulnerability due to improper escaping of special characters in text-protocol mode when the NO_BACKSLASH_ESCAPES SQL mode is enabled. This allows an attacker to inject arbitrary SQL commands by closing string literals improperly. The vulnerability does not affect execute() and batch() methods that use binary protocols. Fixed versions have been released to address this issue.
CVE-2026-107703 is a critical OS command injection vulnerability in the @enmaso/node-convert package up to version 1.0.0. The flaw occurs in convert.js where unsanitized user inputs for filepath and convertTo are passed directly to a child_process.exec() call that runs ImageMagick commands. This allows an attacker to inject shell metacharacters or single quotes to execute arbitrary OS commands with the privileges of the Node.js process.
dot-access versions 0.0.3 through 1.0.0 contain a critical code injection vulnerability. Remote attackers can execute arbitrary JavaScript by supplying crafted paths to the get() function. This occurs because the path input is concatenated into a new Function body, enabling attackers to access constructor.constructor and execute operating system commands via Node.js child_process.
ppt2png versions up to 0.0.6 contain an OS command injection vulnerability. This flaw allows attackers to execute arbitrary operating system commands by injecting shell metacharacters into file name arguments passed to the child_process.exec() function in Node.js. The vulnerability arises from improper sanitization of input or output path arguments.
MariaDB Connector/Node.js versions from 3.2.0 up to but not including 3.2.5, 3.3.0 up to 3.3.4, 3.4.0 up to 3.4.7, and 3.5.0-rc.0 up to 3.5.4 contain a SQL injection vulnerability when the permitSetMultiParamEntries option is enabled. This flaw allows attacker-controlled keys with backticks to inject arbitrary SQL commands, potentially modifying unintended database columns and executing commands with the database user's privileges. The option is disabled by default, and serialized-object handling when disabled is not affected. The issue is fixed in versions 3.2.5, 3.3.4, 3.4.7, and 3.5.4.
MariaDB Connector/Node.js versions prior to 3.2.5, 3.3.4, 3.4.7, and 3.5.4 contain a vulnerability where malformed GeoJSON Polygon and MultiPolygon data can cause uninitialized Node.js heap memory to be disclosed in database values. This occurs because the connector allocates buffer space based on an unchecked numeric length before verifying the ring is an array, leading to potential exposure of sensitive information such as other users' data, session material, database credentials, or TLS key material. The issue is fixed in the specified versions.
A vulnerability in mariadb-connector-nodejs versions 3.3.0 up to but not including 3.5.4 causes an uncaught exception during zero-configuration TLS authentication using the client_ed25519 plugin. This results in a denial of service where the Node.js client process crashes and exits. The issue arises because the Ed25519PasswordAuth.hash() method references an undefined variable, causing a ReferenceError. No credentials or data are exposed, but availability is impacted. The flaw can be triggered by an attacker capable of intercepting the connection and presenting a self-signed certificate. The vulnerability is fixed in version 3.5.4. Workarounds include providing the server certificate to the client or using other authentication plugins.
CVE-2026-107302 is an out-of-bounds read vulnerability in the msgpack5 library for Node.js and browsers. Versions prior to 6.1.0 improperly read the length of a map32 value before fully validating the header, causing a RangeError instead of the expected IncompleteBufferError on truncated input. This can unexpectedly terminate requests, streams, or workers that rely on the IncompleteBufferError to wait for more data. The issue does not lead to memory disclosure and is fixed in version 6.1.0.
CVE-2026-107296 is a low-severity vulnerability in the msgpack5 library for Node.js and browsers. Before version 6.1.0, decoding a negative signed 64-bit integer causes modification of the input buffer bytes used for decoding. This silent corruption affects applications that reuse or retain the encoded input for integrity checks, logging, or later processing. Positive integers and other MessagePack types are not affected. The issue is fixed in msgpack5 version 6.1.0.
Obsidian Desktop versions before 1.14.0 have a high-severity remote code execution vulnerability due to improper sanitization of the data-background-iframe attribute in Markdown notes. This flaw allows attackers to inject JavaScript URLs that bypass DOMPurify and execute in a background iframe via the Reveal.js 4.3.1 Slides plugin. Because Node integration is enabled and context isolation is disabled, the injected script can access Node.js APIs, enabling arbitrary OS command execution when a user opens the malicious note and starts the presentation.
The Drupal module 'Permissions by term' allows restricting view access to nodes based on taxonomy terms. A vulnerability exists where, in 'Permission mode', access rights are not properly checked when a node references a deleted taxonomy term and is accessed via JSON:API. Exploitation requires a specific module configuration, the presence of references to deleted terms, and access through JSON:API. A patch is available for versions prior to 3.1.41.
CVE-2026-106446 is a critical code injection vulnerability in handlebars.js versions 4.0.0 up to but not including 4.7.10. The vulnerability arises because Handlebars.compile() and Handlebars.precompile() accept pre-parsed AST objects without fully validating all node values, allowing untrusted input objects to inject arbitrary JavaScript code. This can lead to remote code execution on the server or malicious code execution in client environments where precompiled templates are used. Applications passing untrusted objects instead of strings to these functions are affected. The vulnerability has a CVSS score of 9.8, indicating critical severity.