CVE-2026-113378 is an OS command injection vulnerability in the mcollina mcp-ripgrep project up to version 0.4.0. The flaw exists in the Advanced Search Tool component, specifically in the handling of the fileType argument in src/index.ts. The vulnerability allows local attackers to inject OS commands due to improper escaping of this argument, while sibling arguments are properly escaped. The exploit code has been publicly released, but the actual existence of the vulnerability is still questioned by some. The project maintainer warns that the MCP server executes shell commands using ripgrep and advises caution with input.
A vulnerability in Siemens Software Center allowed attackers to pair a legitimate signed copy of the software with malicious DLLs to infect Windows PCs. The flaw, CVE-2026-110936, involves improper DLL search path restrictions, enabling local authenticated attackers to execute arbitrary code with Software Center privileges. Siemens released version 4.0.9.8 to fix the issue, with automatic updates for existing users. The attacks are linked to the Romulus ClickFix malware campaign, which uses social engineering to trick users into executing malicious commands. Siemens confirmed no breach of their distribution channels and is sharing threat intelligence with authorities and security vendors.
The YMC Filter WordPress plugin up to version 3.12.19 is vulnerable to stored DOM-based cross-site scripting (XSS) via the 'post_title' parameter. Authenticated users with author-level access or higher can inject malicious scripts that execute when any user accesses the affected page. The vulnerability is exacerbated by an autocomplete REST endpoint that allows unauthenticated users to trigger the injected payload simply by interacting with the search box.
The FiboSearch – Ajax Search for WooCommerce plugin for WordPress is vulnerable to Stored Cross-Site Scripting via the 'purchased_plan' parameter in all versions up to, and including, 1.34.2 due to insufficient input sanitization and output escaping. This makes it possible for authenticated attackers, with subscriber-level access and above, to inject arbitrary web scripts in pages that will execute whenever a user accesses an injected page. Exploitation requires that the site owner has previously completed the standard Freemius opt-in flow; once that condition is met, any Subscriber can reach the vulnerable handler simply by loading /wp-admin/profile.php with the requisite query parameters.
Forminator Forms – Contact Form, Payment Form & Custom Form Builder plugin for WordPress versions up to and including 1.58.1 is vulnerable to arbitrary shortcode execution. This vulnerability allows unauthenticated attackers to execute arbitrary shortcodes via a crafted GET request to the search results page or by submitting an anonymous comment on posts with comments enabled. No specific Forminator content or configuration is required to exploit this issue.
CVE-2026-95182 is a critical vulnerability in DeepSeek Harness (dsh) identified by an untrusted search path issue. This flaw allows attackers to execute arbitrary code by supplying and opening crafted executable files that replace legitimate content. The vulnerability has a CVSS score of 10, indicating maximum severity with network attack vector, no privileges required, no user interaction, and complete impact on confidentiality, integrity, and availability.
Law enforcement authorities from 17 countries in Latin America and Europe arrested 95 suspects in an INTERPOL-coordinated operation targeting the distribution of child sexual abuse material (CSAM) via online messaging groups. The operation, named International Effort Confluencia, involved multiple coordinated actions between March and September 2026. Investigators executed 127 search warrants, rescued a child victim, and seized large quantities of abusive material. The operation highlights the use of messaging platforms for grooming, abuse coordination, and illegal content distribution. Previous related operations have also targeted CSAM distribution networks globally.
Versions 2.2.0 and earlier of the Komodo Periphery agent contain an OS command injection vulnerability due to improper validation of Docker container names. This flaw affects container destruction and container log search operations, allowing an authenticated non-admin user with specific permissions to execute arbitrary commands as root on the host system. The vulnerability enables privilege escalation and full compromise of the managed infrastructure. A patch fixing this issue is available in Komodo Periphery version 2.3.0 and later. Users are strongly advised to update immediately.
CVE-2026-83725 is a heap-based buffer overflow vulnerability in the Microsoft Windows Search Component affecting Windows 10 Version 1607 and other versions. This flaw allows an unauthorized attacker to execute code remotely over a network. The vulnerability has a high severity with a CVSS score of 8.8. Official patches have been released to address this issue.
CVE-2026-108775 is a medium severity SQL injection vulnerability in erzhongxmu JEEWMS version 2026.09.27-W39. The flaw exists in the WvNoticeController.list function within the Search Endpoint component, where the searchstr argument is improperly handled, allowing remote attackers to execute SQL injection attacks. The vulnerability has been publicly disclosed, and no vendor response or patch is currently available.
## 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
Reflected Cross-Site Scripting (XSS) on the BeeTienda e-commerce platform, specifically in the latest demo version. The incident occurs due to a lack of proper sanitization of user input data in the 'search' parameter of the product list endpoint. When malicious payloads are transmitted via the 'search' parameter, they are displayed insecurely in the HTML response, allowing for the arbitrary execution of JavaScript code in the victim's browser.
SumatraPDF is a multi-format reader for Windows. In 3.5.2 and earlier, an attacker-controlled SyncTeX source filename is substituted for the %f placeholder in an external editor command line without safe Windows argument quoting, and the resulting command line is passed to CreateProcessW(). A user with an external editor configured or auto-detected who opens a PDF with a crafted .synctex.gz file and invokes inverse search can inject command-line flags; the resulting impact depends on the target editor interpreting those flags and can include unintended editor actions or code execution through a malicious extension. No broader impact is claimed beyond the advisory-supported conditions. No fixed version is available as of this review.
An argument injection vulnerability exists in the configuration management command-line utility of Brocade Fabric OS versions before 9.2.2d and 10.0.0 through 10.0.0a1. When executing configuration viewing commands with search pattern filters, the utility fails to sanitize user-supplied search string options before passing them to internal search commands. An authenticated user with low-privilege administrative access can exploit this vulnerability to read arbitrary files on the local operating system, including sensitive configuration files, system password hashes and system secrets.
CVE-2026-76268 is a critical vulnerability in Splunk Enterprise versions 10.2.x prior to 10.2.7 and 10.4.x prior to 10.4.3. It allows unauthenticated network users to execute arbitrary operating system commands via the Patroni REST API on search head cluster members, due to lack of authentication on critical configuration operations. Versions 10.0.x and 9.4.x are not affected.
An SQL Injection vulnerability exists in the Site Search function of Movable Type, which may allow an unauthenticated attacker to execute an arbitrary SQL query on the affected product.
The OMGF | GDPR/DSGVO Compliant, Faster Google Fonts. Easy. plugin for WordPress is vulnerable to Stored Cross-Site Scripting via 's' Search Parameter via comments-atom Feed in all versions up to, and including, 6.3.10 due to insufficient input sanitization and output escaping. This makes it possible for unauthenticated attackers to inject arbitrary web scripts in pages that will execute whenever a user accesses an injected page. Successful exploitation requires that the front-end server serves the retained .tmp file without a Content-Type or X-Content-Type-Options header, enabling MIME-sniffing browsers such as Chromium to execute the injected script — a condition present by default on many Apache and nginx/php-fpm deployments.
Perforce P4 Search container images prior to 2026.4.2 enable an unauthenticated Java debug interface. An attacker with network access to this interface can execute arbitrary code as the P4 Search service account, potentially leading to compromise of the connected P4 Server.
Perforce P4 Search container images prior to 2026.4.2 reset the service authentication token to a publicly documented default value. An unauthenticated attacker with network access can obtain the highest application privilege, potentially leading to arbitrary code execution and compromise of the connected P4 Server.
A deserialization of untrusted data vulnerability exists in Apache Directory LDAP API versions from 2.1.0 up to but not including 2.1.9, as well as certain 1.0.0 and 2.1.2 builds. A malicious or compromised LDAP server can respond to a client's loadSchema() subschema search with a schema object containing a serialized Java class, potentially enabling remote code execution. The issue is fixed in version 2.1.9.