/

CVE-2026-34565

Severity:

CRITICAL RISK

(9.1)

Cross-Site Scripting (XSS) in CI4MS Menu Management

CVE-2026-34565

Analyzed

Vulnerability type

Category:

Cross-Site Scripting (XSS)

CWE:

CWE-79

Impact:

Stored Cross-Site Scripting leading to account compromise and UI-level takeover

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 vulnerability in the Menu Management feature, where post-related data is persisted and later rendered without proper output encoding.

An attacker who can influence post content or related metadata may inject malicious JavaScript that executes in both administrative dashboards and public-facing navigation menus when users view affected pages.

Affected context

The vulnerability occurs within CI4MS's Menu Management functionality, specifically when administrators add Posts to navigation menus.

Post-related data selected from the Posts section is stored on the server and then re-used in:

  • Administrative dashboard views for managing menus
  • Public-facing navigation menus rendered to site visitors

The issue is exposed in deployments where post fields or associated metadata can contain attacker-controlled content and are later rendered into the DOM without proper escaping or encoding.

Exploit preconditions

  • Attack surface: Web UI (administrative panel and public navigation menus)
  • Required access:
  • Ability to create or modify posts or post-related data that can be selected into menus (e.g., author, content editor, or any role with content management privileges), or
  • Any vector that allows injecting data into post fields later referenced by Menu Management
  • Trigger point:
  • An administrator uses the Menu Management interface to add affected Posts to a navigation menu, causing the malicious content to be stored in menu configuration.
  • Any user (administrator or public visitor) loads a page where the navigation menu or related admin interface renders the stored values into the DOM.
  • Why exploitation is possible:
  • User-controlled post data is stored server-side and later inserted into HTML/JavaScript contexts without proper output encoding.
  • The DOM or client-side scripts process this data in a way that treats it as executable script, enabling DOM-based XSS when the menu is rendered.

Why this happens

The core issue is improper neutralization of user input before it is placed into web pages, as described by CWE-79: Improper Neutralization of Input During Web Page Generation (Cross-Site Scripting).

CI4MS stores post-related values that originate from user-controlled input and later injects them into the DOM without context-aware escaping.

In particular, menu items derived from posts are rendered in administrative and public views without HTML/JavaScript-safe encoding, and client-side behavior interprets these values in script-capable contexts.

This insecure output handling pattern allows stored data to be transformed into executable JavaScript in the browser.

Potential impact

  • Compromise of administrator or user sessions via session hijacking techniques
  • Execution of arbitrary JavaScript in victims' browsers under the origin of the affected site
  • Unauthorized actions performed on behalf of logged-in administrators (e.g., changing settings, managing content, or modifying users)
  • Theft or manipulation of sensitive data accessible through the web interface
  • Defacement of public-facing navigation elements and broader UX manipulation

General mitigation guidance

Effective mitigation focuses on ensuring that untrusted data is never rendered into a page without proper, context-aware encoding:

  • Apply strict output encoding/escaping for all post-derived values before rendering them into HTML, attribute, URL, or JavaScript contexts.
  • Centralize templating and HTML generation in a view layer that enforces automatic escaping by default, only allowing explicit safe bypasses for fully trusted, validated content.
  • Validate and sanitize inputs for posts and related metadata on the server side, constraining allowed characters and markup according to business needs.
  • Avoid directly concatenating user-controlled data into client-side scripts; instead, pass data through safe serialization (e.g., JSON encoding) and treat it as data, not code.
  • Enforce least-privilege permissions so only trusted roles can manage menu structures and content sources, reducing the chance of malicious content being introduced.
  • Consider applying a Content Security Policy (CSP) that restricts inline scripts and untrusted sources, reducing the impact of XSS if an encoding lapse occurs.

How teams detect issues like this

Detection commonly combines code-level analysis, runtime observation, and review processes:

  • Static analysis: Configure linters or SAST tools to flag unescaped output of user-controlled variables in templates and views, especially where menu items and post-derived data are rendered.
  • Code review: Introduce review checklists requiring verification that all dynamic content in navigation menus and admin dashboards uses centralized escaping helpers and safe templating patterns.
  • Template policy enforcement: Use framework-level settings that default to encoding all variables, and periodically scan for views explicitly disabling escaping or injecting raw HTML.
  • Dynamic testing: Employ automated scanners or browser-based test suites to probe menu-related endpoints for XSS behavior, as well as manual tests inserting benign test payloads into posts and verifying their rendering.
  • Monitoring: Inspect client-side error logs or security monitoring telemetry for anomalous script execution or DOM modification patterns that may indicate active XSS exploitation.

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-xgh5-w62m-8mpr

Frequently asked

questions

Yes. If an attacker can control post content or related metadata that is later used in navigation menus, they can remotely inject JavaScript that executes in the browsers of administrators and site visitors who load affected pages.

Typically, the attacker must have a way to influence post-related data.

In many deployments this implies at least an authenticated role with content creation or editing rights, but in some configurations, publicly submitted or imported content could also be abused if it is later selectable into menus.

The most robust fix is to ensure all post-derived data used in menus is passed through context-aware output encoding before being inserted into the DOM.

Combining automatic escaping in templates with strict server-side validation of post fields significantly reduces the XSS risk surface.

Adopt a "encode on output" rule with a secure templating engine, avoid mixing data and code in client-side scripts, and enforce security-focused code review practices.

Complement these with automated static analysis for unescaped outputs and consider a defense-in-depth measure like Content Security Policy to limit the impact of any remaining XSS flaws.

Find out what's already
exploitable in your codebase.