/

CVE-2026-23841

Severity:

CRITICAL RISK

(9.3)

XSS in Movary categoryCreated Parameter

CVE-2026-23841

Analyzed

Vulnerability type

Category:

Cross-Site Scripting (XSS)

CWE:

CWE-20, CWE-79

Impact:

Client-Side Code Execution and Session Compromise

Severity:

CRITICAL RISK

(9.3)

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

Movary contains a reflected cross-site scripting vulnerability where unvalidated user input passed via the ?categoryCreated= parameter can be rendered back in the browser as executable JavaScript.

An attacker who can lure a user to visit a crafted URL may execute arbitrary scripts in the victim's browser within the context of the Movary application, potentially compromising accounts and sensitive data.

Affected context

The vulnerability occurs in Movary's web interface when the categoryCreated query parameter is reflected in the HTML response without robust validation or output encoding.

It primarily affects scenarios where user-controlled query parameters are displayed back to the user, such as status messages, UI notifications, or dynamically rendered labels.

The risk is elevated when users browse while authenticated, since any injected script runs in their logged-in session and inherits their privileges within the application.

Exploit preconditions

  • Attack surface: Web interface, via HTTP(S) requests to Movary endpoints that accept the ?categoryCreated= query parameter.
  • Required access: Ability to convince a victim to visit a crafted link (e.g., through email, messaging, forums) or to inject such a link into a page the victim will load.
  • Trigger point: The server reflects the categoryCreated value into the response, and the browser interprets it as HTML/JavaScript without proper output encoding.
  • Why exploitation is possible: User-controlled input is not sufficiently validated or encoded before being included in the page, allowing attacker-supplied markup or script to be executed by the browser.

Why this happens

The root cause is insufficiently validated and unsafely rendered user input, which maps to:

  • CWE-79: Improper Neutralization of Input During Web Page Generation (Cross-Site Scripting)
  • CWE-20: Improper Input Validation

In Movary, the categoryCreated query parameter is treated as display content but is inserted into the server-generated response without consistent context-aware output encoding.

This pattern effectively lets the client browser treat untrusted data as part of the page's DOM or JavaScript, enabling execution of arbitrary script in the security context of the Movary application.

Potential impact

  • Execution of arbitrary JavaScript in the victim's browser within the Movary origin.
  • Theft of session identifiers, CSRF tokens, or other sensitive browser-stored information related to Movary.
  • Unauthorized actions performed on behalf of the victim (e.g., changing data, modifying preferences) using their authenticated session.
  • Injection of misleading UI elements or content to phish for credentials or trick users into unsafe actions.
  • Potential pivoting to broader account compromise if Movary is federated or integrated with other identity providers.

General mitigation guidance

Effective mitigation typically combines strict input handling with robust output encoding:

  • Apply context-aware output encoding for any user-controlled data rendered into HTML, attributes, JavaScript, or URLs (e.g., escaping special characters rather than rendering them as markup).
  • Normalize and validate inputs like categoryCreated according to a strict allowlist (e.g., expected characters, length limits, and formats) before storage or use in templates.
  • Separate data from presentation by using templating engines or frameworks that automatically encode variables by default, reducing direct string concatenation into HTML.
  • Enforce a Content Security Policy (CSP) to limit inline script execution and reduce impact if an injection slips through.
  • Follow a least-privilege model on the client side by minimizing sensitive data exposed to scripts and avoiding unnecessary use of powerful browser APIs.

How teams detect issues like this

Detection can focus on both code and runtime behaviors:

  • Use static analysis or linters to flag patterns where untrusted query parameters (such as categoryCreated) flow directly into HTML templates, DOM APIs, or script contexts without encoding.
  • Incorporate secure coding guidelines into code review, looking for:
  • Direct string concatenation into HTML templates.
  • Use of innerHTML or equivalent APIs with user input.
  • Bypassing or disabling default escaping in templating engines.
  • Employ dynamic application security testing (DAST) tools or automated scanners configured to probe query parameters with XSS payloads and analyze responses for reflection.
  • Instrument logging to capture suspicious query parameter values and unusual error patterns that may indicate attempted XSS probes.

Sources

SourceLink
github.comgithub.com/leepeuker/movary/releases/tag/0.70.0
github.comgithub.com/leepeuker/movary/security/advisories/GHSA-v877-x568-4v5v

Frequently asked

questions

Yes. An attacker can remotely exploit the issue by sending or embedding a specially crafted Movary URL containing a malicious categoryCreated value. When a victim loads that URL, the script can execute in their browser.

The attacker does not need to be authenticated to craft a malicious URL. However, the impact is significantly higher when the victim is logged into Movary, since injected scripts then run with the victim's session privileges.

The most robust fix is to enforce context-aware output encoding for all user-controlled data rendered in pages, combined with strict server-side validation and normalization of query parameters. Avoid any direct insertion of raw user input into HTML or script contexts.

Adopt secure-by-default templating or frontend frameworks that automatically escape output, enforce input validation standards, add automated checks for XSS patterns in CI/CD, and use defense-in-depth measures like CSP and secure coding guidelines to consistently treat all user input as untrusted.

Find out what's already
exploitable in your codebase.