CVEReports
CVEReports

Automated vulnerability intelligence platform. Comprehensive reports for high-severity CVEs generated by AI.

Product

  • Home
  • Sitemap
  • RSS Feed

Company

  • About
  • Contact
  • Privacy Policy
  • Terms of Service

© 2026 CVEReports. All rights reserved.

Made with love by Amit Schendel & Alon Barad



GHSA-V7QW-HX66-4W9X

GHSA-v7qw-hx66-4w9x: Stored Cross-Site Scripting (XSS) in NetBox Data Flows Plugin

Alon Barad
Alon Barad
Software Engineer

May 8, 2026·6 min read·38 visits

Executive Summary (TL;DR)

The netbox-data-flows plugin improperly escapes ObjectAlias names before rendering them in DataFlow tables. Authenticated users can inject malicious scripts into these fields, leading to stored XSS that can compromise high-privileged administrators.

A stored Cross-Site Scripting (XSS) vulnerability exists in the netbox-data-flows plugin for NetBox, affecting versions prior to 1.5.1. Authenticated attackers with permissions to modify ObjectAlias records can inject arbitrary HTML and JavaScript, which executes in the context of other users viewing DataFlow tables.

Vulnerability Overview

The netbox-data-flows plugin extends NetBox, an infrastructure resource modeling tool, to support the documentation of network data flows. This vulnerability represents a classic Stored Cross-Site Scripting (CWE-79) weakness within the administrative interface of this plugin. The vulnerability allows authenticated users with relatively low privileges to inject persistent malicious payloads into the system database.

The attack surface is exposed through the ObjectAlias management view. Users with permissions to create or modify ObjectAlias entities can input arbitrary HTML and JavaScript into the alias name field. Because the application fails to neutralize this input before persisting it, the payload is stored directly in the underlying database without sanitization.

When other users access the DataFlow table views, the application retrieves these malicious alias names and renders them as part of the HTML document. This execution occurs within the context of the victim's browser session, granting the attacker access to the victim's NetBox session state, CSRF tokens, and application interface.

Root Cause Analysis

The root cause of this vulnerability lies in the improper use of Django's mark_safe function combined with Python's formatted string literals (f-strings). Django's template engine includes automatic HTML escaping by default to prevent XSS. However, developers can explicitly disable this protection for specific strings by wrapping them in the mark_safe() utility.

In netbox_data_flows/utils/helpers.py, the object_list_to_string function is responsible for rendering custom table columns. The function constructs HTML anchor tags by iterating over a list of objects. It uses an f-string to interpolate the object's URL and its string representation directly into an HTML string: f'<a href="{o.get_absolute_url()}">{o}</a>'.

When the {o} placeholder is evaluated, Python implicitly calls the __str__ method of the ObjectAlias object, returning the user-controlled alias name. Because this entirely unescaped string is immediately passed into mark_safe(), Django trusts the resulting HTML snippet completely. The template engine renders the unescaped user input verbatim, executing any embedded JavaScript in the process.

Code Analysis

An analysis of the vulnerable object_list_to_string function reveals the exact mechanism of the flaw. The developer intended to return a comma-separated list of active hyperlinks, but prioritized convenience over security by bypassing the framework's output encoding.

# Vulnerable implementation in netbox_data_flows/utils/helpers.py
from django.utils.safestring import mark_safe
 
def object_list_to_string(objects, separator=", "):
    # The variable 'o' expands to the unescaped string representation of the object
    return mark_safe(
        separator.join(f'<a href="{o.get_absolute_url()}">{o}</a>' for o in objects)
    )

The fundamental error is interpolating raw variables into an HTML context before applying output encoding. The correct approach in Django requires either escaping the variable explicitly before string interpolation, or utilizing django.utils.html.format_html(), which safely handles argument escaping while constructing HTML structures.

> [!NOTE] > Using format_html instead of mark_safe with f-strings is a crucial security pattern in Django. format_html applies escaping to its arguments before inserting them into the template string, effectively mitigating this class of XSS vulnerability.

Exploitation Methodology

Exploitation of this vulnerability requires an attacker to possess active credentials to the NetBox instance, specifically with permissions to manage ObjectAlias and DataFlow records. The attack proceeds in distinct phases: payload injection, binding, and execution.

First, the attacker navigates to the ObjectAlias creation interface and injects a standard XSS vector into the name field. A viable proof-of-concept payload utilizes the <img> tag with an intentional error to trigger execution: <img src=x onerror=alert(document.domain)>. The application accepts this input and stores it in the database.

Next, the attacker must ensure the payload is rendered in a commonly viewed area. They create or modify a DataFlow record, assigning the malicious ObjectAlias as either a source or destination. This binds the poisoned data to the primary table view.

Finally, the payload executes passively. When a victim (such as a NetBox administrator) loads the Data Flow list page or any model tab rendering the DataFlowTable, the application processes the object_list_to_string function. The browser parses the resulting HTML, encounters the malicious <img> tag, fails to load the nonexistent source x, and immediately executes the JavaScript defined in the onerror handler.

Impact Assessment

The impact of this vulnerability is designated as High due to the context in which NetBox operates. NetBox functions as a central source of truth for network infrastructure, often containing sensitive topologies, device credentials, and configuration states. Exploitation leverages the implicit trust boundaries of the application.

The CVSS v3.1 vector evaluates to CVSS:3.1/AV:N/AC:L/PR:L/UI:R/S:C/C:H/I:H/A:N (8.7). The scope change (S:C) reflects the fact that an attacker with low privileges can execute actions in the security context of a high-privilege victim. User interaction (UI:R) is strictly required, as the victim must actively navigate to the poisoned page.

Successful exploitation allows the attacker to execute arbitrary JavaScript in the victim's browser session. This capability enables the extraction of session identifiers, CSRF tokens, and sensitive data visible within the NetBox interface. More critically, an attacker can script the victim's browser to silently issue state-changing administrative API requests in the background, effectively elevating their privileges and altering infrastructure records without direct authorization.

Remediation Guidance

The primary remediation strategy is to upgrade the netbox-data-flows package to version 1.5.1 or later. This release addresses the vulnerability by modifying the custom table column rendering logic to properly encode user input before marking the resulting string as safe for HTML rendering.

Administrators should verify the installed package version using the pip show netbox-data-flows command within the NetBox Python environment. If the version is prior to 1.5.1, an immediate update should be scheduled. Following the upgrade, the NetBox service must be restarted to ensure the new plugin code is loaded into memory.

As a proactive measure, security teams can audit existing ObjectAlias records in the database for potential indicators of compromise. Database queries or API scripts should search the name field for common HTML tags (e.g., <script>, <img>, <iframe>) and event handlers (e.g., onerror, onload). Identifying such patterns may indicate attempted or successful exploitation prior to patching.

Official Patches

GitHub AdvisoryOfficial security advisory and patch notification

Technical Appendix

CVSS Score
8.7/ 10
CVSS:3.1/AV:N/AC:L/PR:L/UI:R/S:C/C:H/I:H/A:N

Affected Systems

NetBox implementations utilizing the netbox-data-flows plugin < 1.5.1

Affected Versions Detail

Product
Affected Versions
Fixed Version
netbox-data-flows
Alef-Burzmali
< 1.5.11.5.1
AttributeDetail
CWE IDCWE-79 (Cross-site Scripting)
Attack VectorNetwork
CVSS v3.18.7 (High)
ImpactSession Hijacking, Privilege Escalation
Exploit StatusProof of Concept Available
Authentication RequirementRequired (Low Privileges)

MITRE ATT&CK Mapping

T1190Exploit Public-Facing Application
Initial Access
T1059.007Command and Scripting Interpreter: JavaScript
Execution
CWE-79
Cross-site Scripting

Improper Neutralization of Input During Web Page Generation ('Cross-site Scripting')

Known Exploits & Detection

GitHub AdvisoryProof of Concept methodology detailing the injection of <img src=x onerror=alert(document.domain)> into an ObjectAlias name.

Vulnerability Timeline

Vulnerability Published
2026-05-07
Advisory Modified and Patch Released
2026-05-07

References & Sources

  • [1]GitHub Advisory GHSA-v7qw-hx66-4w9x
  • [2]Package Repository
  • [3]OSV Record

Attack Flow Diagram

Press enter or space to select a node. You can then use the arrow keys to move the node around. Press delete to remove it and escape to cancel.
Press enter or space to select an edge. You can then press delete to remove it or escape to cancel.

More Reports

•30 minutes ago•CVE-2026-110789
7.5

CVE-2026-110789: Pre-Authentication Denial of Service via ASN.1 DER Length Parsing in js-libp2p (@libp2p/crypto)

CVE-2026-110789 (GHSA-rvfr-cqwq-rc4j) is a high-severity pre-authentication Denial of Service (DoS) vulnerability in the @libp2p/crypto package of the js-libp2p networking stack prior to version 5.1.22. An improper length validation flaw in the ASN.1 DER decoder allows an unauthenticated remote peer to send a crafted RSA public key during the Identify protocol exchange, forcing the parser into a synchronous loop over attacker-claimed length values. Because this loop executes within a single Node.js event-loop tick prior to identity or cryptographic signature verification, it bypasses application timeouts, stalls the event loop for 4 to 5 seconds per connection, and transiently allocates up to 2 GB of memory.

Amit Schendel
Amit Schendel
2 views•11 min read
•about 2 hours ago•CVE-2026-119793
7.5

CVE-2026-119793: Unbounded Topic Map Allocation Denial of Service in js-libp2p GossipSub

CVE-2026-119793 (GHSA-x2vm-cf3p-m2w8) is a resource consumption vulnerability in the @libp2p/gossipsub module of the js-libp2p ecosystem. Prior to @libp2p/gossipsub version 17.0.0 and js-libp2p version 3.3.9, the GossipSub implementation processed incoming subscription RPC messages without enforcing per-peer or global limits on the number or cumulative byte size of subscribed topics in its default configuration. An unauthenticated remote peer can exploit this flaw by streaming continuous batches of unique topic subscription strings over an established connection, causing unbounded growth of the internal topics Map. This leads to V8 heap exhaustion (Out-Of-Memory crash) and severe CPU starvation on the main event loop during peer disconnection teardown.

Amit Schendel
Amit Schendel
3 views•12 min read
•about 3 hours ago•CVE-2026-69241
5.4

CVE-2026-69241: Stored Cross-Site Scripting via Unsanitized SVG Upload in Filament Curator

Filament Curator, a media picker plugin for Filament panels in Laravel applications, contains a Stored Cross-Site Scripting (XSS) vulnerability in versions prior to 3.7.9, 4.1.2, and 5.1.2. The application accepts image/svg+xml uploads by default and stores them on disk without stripping executable XML markup. When a panel user opens an uploaded SVG via the View action, the file renders as a top-level document in the browser, executing embedded JavaScript within the origin of the Filament application.

Alon Barad
Alon Barad
4 views•9 min read
•about 6 hours ago•CVE-2026-63182
8.1

CVE-2026-63182: XML Signature Wrapping Authentication Bypass in LightSAML

CVE-2026-63182 is a high-severity XML Signature Wrapping (XSW) vulnerability in LightSAML (litesaml/lightsaml), a PHP library implementing SAML 2.0 data models and cryptographic verification. An architectural discrepancy between how LightSAML deserializes direct child assertions and how the underlying robrichards/xmlseclibs library resolves XML document fragment identifiers allows an attacker with a valid signed assertion to forge arbitrary SAML identity claims and bypass authentication.

Alon Barad
Alon Barad
4 views•11 min read
•about 7 hours ago•CVE-2026-119351
6.3

CVE-2026-119351: Cross-Context Cache Leak via Delayed Inner Stream Metadata in Next.js

A race condition and improper synchronization vulnerability (CWE-362) exists in Next.js versions 16.2.0 prior to 16.4.5 when Cache Components ('use cache' directive) are enabled. When an outer cached function calls a nested cached function that reads dynamic root parameters via 'next/root-params' and returns an object containing pending promises, React Flight can resolve and deliver the ready portion of the payload before the inner cache finishes publishing its root parameter dependencies. Consequently, the outer cache entry finalizes and persists under a cache key that omits the root parameter dependencies, causing the first written cache entry to be served across requests with different root parameter values and bypassing nested cache invalidation rules.

Amit Schendel
Amit Schendel
7 views•10 min read
•about 7 hours ago•CVE-2026-68934
8.7

CVE-2026-68934: OS Command Injection in code-review-mcp-server via Unsafe Shell Execution

A remote OS command injection vulnerability (CWE-78) exists in code-review-mcp-server prior to version 1.5.3. The application passes caller-controlled tool parameters directly into Node.js child_process.execSync() calls without proper neutralization. An attacker or compromised LLM agent invoking tools such as getLocalGitDiff, codeReview, createPR, or getPRTemplate can inject arbitrary shell commands that execute with the privileges of the MCP server host process.

Alon Barad
Alon Barad
10 views•11 min read