/

CVE-2026-34564

Severity:

CRITICAL RISK

(9.1)

Cross-Site Scripting (XSS) in CI4MS Menu Management

CVE-2026-34564

Analyzed

Vulnerability type

Category:

Cross-Site Scripting (XSS)

CWE:

CWE-79

Impact:

Client-Side Code Execution / Session Compromise

Severity:

CRITICAL RISK

(9.1)

CVSS version:

3.1

Catch this CVE while code is being written

Detect vulnerable code directly in pull requests, so CVEs are fixed before merge.

Summary

CI4MS versions prior to 0.31.0.0 contain a stored DOM-based cross-site scripting (XSS) vulnerability in the Menu Management feature, where page-related data is saved and later rendered without proper output encoding.

An attacker who can influence page data added to navigation menus may inject JavaScript that executes in the browser of both administrators and public site visitors when affected menus are viewed.

Affected context

The vulnerability occurs in CI4MS's Menu Management functionality when Pages are added to navigation menus.

User-controlled page data is stored server-side and later rendered into both administrative views and public-facing navigation menus without sufficient output encoding.

The risk is present in deployments where untrusted or semi-trusted users can create or influence page content or menu entries, and that content is then reflected into the DOM of visitors' browsers.

Exploit preconditions

  • Attack surface: Web-based UI, specifically the Page and Menu Management workflows.
  • Required access: Ability to create or modify page-related data that can be linked or added to navigation menus (e.g., content editors, compromised accounts, or any feature exposing page fields to untrusted input).
  • Trigger point: Viewing an affected administrative interface or public navigation menu in a browser, causing the stored payload to be inserted into the DOM.
  • Why exploitation is possible: Page data is stored and later rendered without proper context-aware output encoding, allowing attacker-supplied script or event attributes to execute in the victim's browser.

Why this happens

The underlying issue maps to CWE-79: Improper Neutralization of Input During Web Page Generation.

CI4MS stores page-related data selected through the Pages section and inserts it into navigation menus without applying appropriate output encoding for the HTML/JavaScript context in which it is rendered.

On the client side, DOM manipulation then uses this data in a way that treats it as active markup or script, rather than inert text.

This combination of insufficient server-side encoding and unsafe client-side rendering logic forms a classic stored DOM-based XSS pattern.

Potential impact

  • Theft of administrator or user session cookies, potentially leading to account takeover.
  • Execution of arbitrary JavaScript in visitors' browsers under the trust of the affected site.
  • Unauthorized actions performed on behalf of logged-in users via browser-based requests (e.g., CSRF-like effects driven by injected script).
  • Defacement of navigation menus or injection of malicious links and content.
  • Use of the site as a launch point for phishing or malware delivery to visitors.

General mitigation guidance

Effective mitigation relies on combining robust output encoding with careful client-side handling of dynamic content:

  • Apply strict, context-aware output encoding for all page-related data rendered into templates and navigation menus (HTML element content, attributes, URLs, JavaScript contexts).
  • Treat stored page and menu data as untrusted on every render, regardless of where it originated, and avoid directly inserting raw HTML unless explicitly and safely whitelisted.
  • On the client side, avoid using APIs or patterns that interpret data as HTML/JS (e.g., innerHTML) when not strictly necessary; prefer text-based APIs (e.g., textContent, safe attribute setters).
  • Restrict which roles can create or modify menu-linked content, and apply validation rules that reject dangerous patterns (e.g., script tags, event handlers, javascript: URLs) where possible.
  • Use Content Security Policy (CSP) to reduce the impact of any residual XSS by disallowing inline scripts and limiting script sources.

How teams detect issues like this

Organizations can detect and monitor for similar XSS issues using a combination of code and runtime analysis:

  • Static analysis: Configure SAST rules to flag unencoded output of user-controlled data in views, especially when using templating helpers or directly echoing variables into HTML or JS contexts.
  • Code review signals: During manual reviews, look for use of raw output functions, direct DOM writes (e.g., innerHTML, document.write), or concatenation of user data into HTML fragments or URLs.
  • Security testing: Use automated DAST tools and manual penetration testing to exercise page creation, menu management, and other content features with XSS test payloads, verifying both admin and public views.
  • Policy enforcement: Integrate linters or framework-specific security checks in CI pipelines to enforce safe encoding APIs and discourage unsafe rendering practices.

Sources

SourceLink
github.comgithub.com/ci4-cms-erp/ci4ms/releases/tag/0.31.0.0
github.comgithub.com/ci4-cms-erp/ci4ms/security/advisories/GHSA-g4pp-fhgf-8653

Frequently asked

questions

Yes. If an attacker can remotely create or modify page content that is later added to a navigation menu, they can store a payload that executes in the browser of anyone who views the affected admin or public pages.

The attacker must be able to influence page-related data that can be linked in menus—this could be via a low-privileged content role, a compromised user account, or any functionality that ingests untrusted input and surfaces it through the Pages section.

Consistently apply context-aware output encoding to all data rendered into HTML, attributes, URLs, and scripts, and ensure client-side code uses safe DOM APIs that treat incoming data as text rather than HTML or JavaScript.

Standardize on secure templating conventions, enforce output encoding defaults, include XSS-focused checks in code review and automated testing, and adopt defense-in-depth measures like CSP and least-privilege role design for content management features.

Find out what's already
exploitable in your codebase.