MLflow versions from 2.19.0 up to but not including 3.17.0 contain a vulnerability where the mlflow.crewai.autolog() function records CrewAI Agent objects without properly sanitizing nested credential data. This results in plaintext provider API keys being included in trace data sent to the MLflow trace backend or OTLP destinations, exposing sensitive credentials to unauthorized readers. The issue is resolved in version 3.17.0.
CVE-2026-99084 is a vulnerability in the Linux kernel's readdir implementation where an inode lock is not taken on an immutable directory. This can cause readers to hold a shared lock for extended periods, potentially stalling other operations such as mkdir or lookups in certain mount namespaces. The issue affects specific Linux kernel versions and has been resolved by adding an immutable flag to directories that never change, allowing iterate_dir() to skip the lock.
CVE-2026-98942 is a vulnerability in the Linux kernel's scheduler extension (sched_ext) related to how cid tables are built and published. The issue arises because cid tables were visible to cid kernel functions while being modified, allowing racing tracing or syscall programs to read uninitialized or inconsistent memory. The fix involves building cid tables privately and publishing them with Read-Copy-Update (RCU) synchronization to ensure readers only see fully built tables. The vulnerability affects Linux kernel version 7.2.
CVE-2026-114654 is a numeric-type conversion vulnerability in the BSON handling library of the MongoDB C# Driver. It allows an unauthenticated attacker to supply out-of-range binary subtype values via untrusted textual input, bypassing integrity checks. This causes the driver to emit malformed binary data that may be rejected or misinterpreted by subsequent readers. The issue affects versions from 2.0.0 up to but not including 3.13.0 and has been fixed in version 3.13.0.
CVE-2026-78066 is a resource exhaustion vulnerability in Apache bRPC versions prior to 1.18.0. Multiple parsers handling wire-controlled input do not limit the sizes declared by clients or the decompressed output, allowing attackers to cause excessive memory consumption and crash the service. The issue affects gzip/zlib/snappy decompressors, AMF string readers, RTMP chunk headers, sofa-pbrpc parser, and mcpack2pb message handling. The vulnerability is fixed in Apache bRPC version 1.18.0.
ConnectBot SSH Client Library is written in Kotlin with Kaitai Struct and KStateMachine. Prior to 0.3.1, DerReader.readLength() accepts excessive long-form DER length octets, accumulates them into an Int, and primitive readers allocate arrays without checking the declared size against the remaining input. An application or user that loads an attacker-provided private-key file through SshClient.authenticatePublicKey(), SshKeys.decodePemPrivateKey(), SshSigning.sign(), or SshSigning.getPublicKey() can trigger integer wraparound, excessive allocation, or an uncaught OutOfMemoryError. SSH server host keys and agent-forwarding messages do not use this application-supplied private-key input path. No usable weakened key and no confidentiality or integrity impact have been demonstrated. This issue is fixed in version 0.3.1.
FreeRDP versions from 3.9.0 up to but not including 3.32.0 contain an out-of-bounds read vulnerability in the RDPEAR NDR scalar readers. This flaw occurs because the code checks value length before consuming alignment padding, allowing malicious or compromised RDP servers to send crafted unaligned RDPEAR payloads. Such payloads, including CreateApReqAuthenticatorReq messages, can cause the client process to over-read memory and potentially crash. The vulnerability affects clients using Remote Credential Guard. The CVSS score is 5.3, indicating medium severity, with no confidentiality or integrity impact but a potential denial of service via client crash. No patch or remediation information is provided in the data. No known exploits in the wild have been reported.
## 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
Pydantic AI is a Python agent framework for building applications and workflows with Generative AI. From 0.3.4 until 1.107.6 and 2.44.0, OpenTelemetry instrumentation configured with InstrumentationSettings(include_content=False) can still export sensitive agent content through exception.message and exception.stacktrace events, error status descriptions, and model_request_parameters containing instructions or the prompted_output_template. The exposed data is available to readers of the configured telemetry backend and can include tool feedback, provider error bodies, runtime instructions, and structured-output templates even though message attributes are redacted. This issue does not grant new access to agent data, and deployments that do not use include_content=False are not affected by the setting bypass. This issue is fixed in versions 1.107.6 and 2.44.0.
Inefficient algorithmic complexity in the bounce and complaint processing of Progressive Robot hMailServer 6.3.4 and 6.3.5 allows a remote unauthenticated attacker to stop mail delivery by sending messages, when bounce processing or complaint processing is enabled or a mailing list is managed by the server (none is by default). The readers of incoming delivery status notifications (RFC 3464) and abuse feedback reports (RFC 5965) removed the blank lines at the start of the returned headers part two bytes at a time, copying the rest of the part each time, so their work grew with the square of the number of blank lines. A message shaped like such a report, whose headers part begins with a very large number of blank lines within the reader's 2 MB limit, keeps a delivery thread busy for over a minute while it is delivered, and a few such messages a minute keep every delivery thread busy.
CVE-2026-106494 is a medium severity vulnerability in the @backstage/backend-defaults package where improper input validation in cloud storage URL readers allows an attacker with write access to a cloud storage bucket to craft object names that collide with protected files in the output directory, potentially leading to content injection. This issue is patched in version 0.17.8.
The Apache Thrift Lua TJsonProtocol string and number readers lack size bounds, resulting in quadratic complexity during processing. This vulnerability is identified as CVE-2026-94655 and affects versions 3.0 and 4.0 of the product. No CVSS score or detailed impact information is provided.
CVE-2026-94644 is a vulnerability in Apache Thrift's PHP TJSONProtocol where string and number readers lack size bounds. This flaw could potentially lead to resource exhaustion or other issues due to unbounded input processing. The affected versions are 3.0 and 4.0. No CVSS score or detailed impact information is provided, and no known exploits are reported in the wild.
Apache Thrift's PHP code generation with the option '--gen php:inlined' for struct readers and the TProtocol::skipBinary function lack a recursion-depth guard. This vulnerability could potentially lead to issues such as stack overflows or denial of service if deeply nested data structures are processed without limits.
yawkat LZ4 Java provides LZ4 compression for Java. Prior to 1.11.2, net.jpountz.lz4.LZ4BlockInputStream refill() validates that the compressedLen field in a legacy LZ4Block header is nonnegative but allocates a compressed-input buffer of that attacker-controlled size before reading payload data, allowing a header-only stream to request a near-2 GiB allocation and exhaust the JVM heap. Canonical writers emit raw blocks when compression is not smaller than the original block, but vulnerable readers accept non-canonical oversized compressed blocks. This issue is fixed in version 1.11.2.
CVE-2026-98342 is a use-after-free vulnerability in the Linux kernel's dmaengine subsystem. It occurs because the dma_device structure can be freed while concurrent RCU readers are still accessing it, due to missing synchronization before freeing the device. This flaw was fixed by adding an unconditional synchronize_rcu() call to ensure all RCU readers complete before the device is freed.
CVE-2026-98284 is a medium-severity vulnerability in the Linux kernel's netlink subsystem where the nlk->groups bitmap can be freed while lockless readers still access it, leading to potential use-after-free conditions. The issue arises because netlink_realloc_groups() uses krealloc() which immediately frees the old bitmap if it moves to a different memory bucket, but some readers do not hold the netlink table lock and can access the freed memory. The fix involves allocating a new bitmap and deferring freeing the old one until after an RCU grace period, and adjusting the order of publishing the groups pointer and group count to ensure safe lockless reads.