In Progress ShareFile Storage Zones Controller v5.12.6 and below, improper validation of outbound request destinations and parameters, unsafe JSONP response formatting, and insufficient validation on queue service can be chained by a remote unauthenticated attacker to issue server-side requests to unintended local handlers and perform unauthorized queue operations.
CVE-2024-24786 is a vulnerability in the golang-protobuf library where the protojson unmarshaling function can enter an infinite loop when parsing certain invalid JSON inputs, especially when decoding messages containing Any values or when configured to discard unknown fields. This can be exploited remotely by submitting crafted JSON payloads, causing excessive CPU usage and application hang, resulting in a denial of service (DoS). The impact is limited to DoS without compromising data confidentiality or integrity. Red Hat Hardened Images including the rekor-server package have been updated to version 1.5.4-0.2.hum1 to address this issue. No mitigation other than applying the update is currently recommended by Red Hat.
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.
CVE-2026-108578 is an information disclosure vulnerability in the Neterbit NW-431F device, specifically related to an unknown function handling the /sms.json file in its Embedded Web Server component. The vulnerability can be exploited remotely without authentication. The vendor has not responded to disclosure attempts, and no patch or remediation information is currently available.
SillyTavern versions 1.12.13 through 1.19.0 have a denial of service vulnerability due to the body-parser middleware processing large request bodies before authentication and whitelist checks. This allows unauthenticated remote attackers to send large or compressed JSON or urlencoded payloads, up to 500 MB, potentially in parallel, to exhaust server memory and CPU resources, causing service disruption.
The Divi Plus WordPress plugin versions up to and including 2.4.0 contain a path traversal vulnerability in the /wp-json/elicus/v1/dipl-modules/svg-animator REST endpoint. This flaw allows unauthenticated attackers to read arbitrary files on the server by exploiting insufficient validation of the 'svg_image' parameter. The endpoint's permission callback returns true unconditionally, and sanitization functions used do not prevent access to filesystem paths or URLs. This vulnerability has a high severity rating with a CVSS score of 7.5.
The SiteOrigin Widgets Bundle WordPress plugin up to version 1.74.3 contains a directory traversal vulnerability in the get_instance_css function. Authenticated users with contributor-level access or higher can exploit this flaw to read arbitrary files on the server. This occurs because the normal input sanitization pipeline is bypassed when the shortcode handler calls the widget function directly on attacker-supplied JSON data.
The Post Export Import with Media plugin for WordPress contains a directory traversal vulnerability in all versions up to and including 1.17.1. Authenticated users with administrator-level privileges can exploit this flaw by uploading a crafted ZIP archive containing a media_metadata.json file with path traversal sequences in the 'file_path' parameter. This allows reading arbitrary files on the server, potentially exposing sensitive information. The vulnerability bypasses extension checks introduced in version 1.13.2. The CVSS score is 4.9, indicating medium severity.
CVE-2026-108258 is a path traversal vulnerability in py-shiny, a Python framework for interactive web applications. Versions from 1.4.0 up to but not including 1.6.4 allow an unauthenticated attacker to manipulate the bookmark restore feature by supplying a crafted state_id. This can lead to unauthorized reading of files outside the intended bookmark directory, including sensitive files like input.json and values.json. Additionally, in configurations using server-side bookmark storage and ui.input_file(), attackers can copy and expose arbitrary files from the server. The issue is fixed in version 1.6.4.
CVE-2026-107839 is a high-severity vulnerability in luskaner's ageLANServer prior to version 1.15.2. The vulnerability arises from the POST /game/cloud/getFileURL handler, which lacks limits on the size of the request body and the length of an attacker-controlled JSON array. This can lead to uncontrolled memory allocation, causing the server to crash or hang, disrupting active players and making the service unavailable until restarted. The issue is resolved in version 1.15.2.
MariaDB server is a community developed fork of MySQL server. From 10.6.1 until 10.6.28, 10.11.19, 11.4.13, 11.8.9, 12.3.3, and 13.0.2, the mysql_json plugin assumed that imported MySQL tables contained valid MySQL binary JSON data. A specially prepared MySQL table containing invalid JSON data could cause out-of-bounds reads, information disclosure, or a server crash. This issue is fixed in versions 10.6.28, 10.11.19, 11.4.13, 11.8.9, 12.3.3, and 13.0.2.
## 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
The npm package @galicia-toolkit-nestjs/commons contains a malicious native binary that collects sensitive environment variables related to cloud and CI credentials, along with system information, and exfiltrates this data to a hardcoded external server. The package mimics an internal organizational scope to trick users into installing it, and it persists by daemonizing a background process. Multiple published versions are affected, and no source code or build tooling is provided for the native component, making its behavior opaque.
A URL redirection vulnerability (CWE-601) exists in AdonisJS HTTP Server versions prior to 8.2.3 and between 9.0.0 and before 9.3.0. The issue arises because route parameter values are inserted into URLs without proper encoding, allowing attacker-controlled input to create scheme-relative external URLs. This can enable attackers to redirect users to malicious sites, potentially facilitating phishing or abuse of authentication flows. The vulnerability is fixed in versions 8.2.3 and 9.3.0.
mongo-c-driver is a project that includes two libraries: libmongoc, a client library written in C for MongoDB. libbson, a library providing useful routines related to building, parsing, and iterating BSON documents.
Security Fix(es):
An out-of-bounds read in SCRAM authentication response parsing in the MongoDB C Driver can read one byte beyond a fixed-size buffer when processing a malformed server-final message. A server or network intermediary able to provide this message before server-signature verification can cause the application using the driver to terminate. The extra byte is not returned through the protocol.(CVE-2026-106428)
An off-by-one error in the BSON bulk document writer in the MongoDB C Driver can write one zero byte immediately past a heap allocation when a document ends at a specific buffer boundary. An actor who can influence the size of documents serialized by an embedding application can corrupt adjacent process memory or terminate the process. Reaching this issue requires the application to use the BSON bulk-writer API and produce a precise cumulative document size.(CVE-2026-106431)
The BSON buffer-reservation API in the MongoDB C Driver can record a length smaller than the five-byte BSON minimum. Later append or comparison operations can underflow unsigned length calculations and read or write outside the document buffer. An actor who can influence the length supplied by an embedding application can cause the application to terminate or read or corrupt adjacent process memory. Reaching this issue requires the application to pass an undersized value to bson_reserve_buffer and then perform an affected operation.(CVE-2026-106437)
An incorrect calculation in Decimal128 string parsing in the MongoDB C Driver can accept certain over-precision inputs containing leading zeros instead of rejecting them. This produces a value different from the supplied text. An actor who can provide a decimal string to an embedding application, including through Extended JSON parsing, can cause the application to store or use an incorrect numeric value.(CVE-2026-106438)
A size check in the client-side authentication path of the MongoDB C Driver can wrap around, so an unusually large user-name value is accepted and copied past the end of a small buffer. A party able to set the driver's connection settings may cause the application that embeds the driver to terminate unexpectedly. Reaching this code requires a build in which the optional external SASL authentication backend is present and a connection configured to use it.(CVE-2026-88035)
Improper neutralization of special elements in data query logic in the GridFS component of the MongoDB C Driver can cause a caller-supplied structured file identifier to be interpreted as a query condition rather than as a literal identifier. An authenticated user who can influence the identifier passed by an affected application may obtain stored file content beyond the intended target or cause all GridFS file chunks in the affected bucket to be removed, rendering stored file content unreadable.(CVE-2026-88036)
A flaw in libmongoc's SCRAM authentication implementation caused the client to continue the authentication handshake and transmit the client proof even when a nonce mismatch was detected in the server's first message. An unauthorized party with a man-in-the-middle position could exploit this by injecting a crafted server-first-message containing a controlled salt and low iteration count, then capturing the resulting client proof to perform offline password cracking. This vulnerability is mitigated by TLS, which is standard in production deployments.(CVE-2026-93394)
A missing lower-bound validation in the bson_new_from_buffer() function of libbson allows an integer underflow when processing BSON data with a zero-length prefix. The function reads a 32-bit document length from the input buffer but does not verify that the value is at least 5 (the minimum valid BSON document size) before using it in an array index calculation. When the length field is zero, the expression used to check the document's null terminator wraps to UINT32_MAX, causing a heap out-of-bounds read that crashes the process. An unauthorized party who can supply crafted BSON input to an application using this API can cause a denial of service.(CVE-2026-93395)
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.
Inefficient algorithmic complexity in the JSON reader of Progressive Robot hMailServer allows a remote unauthenticated attacker to make the mail services unavailable. Reading a JSON object kept the first of each duplicated member name by searching the members already read, so an object of N distinct member names cost O(N^2): 1 MB took 8.9 seconds and 4 MB took 300 seconds against the affected code. A remote attacker reaches the reader without an account by mailing a crafted TLS-RPT report (up to 16 MB after decompression) to a hosted domain's published report mailbox, which is read on a delivery thread; a few such reports hold every delivery thread (ten by default), so the server delivers no mail, local or outbound, for over an hour per report. A signed-in account reaches the same 16 MB body through the webmail's own REST routes, holding the REST API's own worker threads. Where no report mailbox is configured, the unauthenticated REST sign-in routes that read a JSON body are capped at 64 KB and are not affected.
The Super Forms – Drag & Drop Form Builder plugin for WordPress contains a critical vulnerability (CVE-2026-17609) that allows unauthenticated attackers to recursively delete arbitrary directories on the server. This affects all versions up to and including 6.3.316. The issue arises from insufficient validation of attacker-controlled JSON fields and a bypassable ABSPATH guard, enabling directory deletion when the 'Delete files from server after form submissions' setting is enabled by an administrator.
ONLYOFFICE Docs Server has a path traversal vulnerability (CVE-2021-3199) that occurs when JSON Web Tokens (JWT) are used. The flaw involves a /.. sequence in an image upload parameter, which could allow an attacker to execute remote code on the server. This vulnerability has been exploited in the wild. No specific affected versions or patch information is provided.