/

CVE-2026-23839

Severity:

CRITICAL RISK

(9.3)

XSS in Movary categoryUpdated Parameter

CVE-2026-23839

Analyzed

Vulnerability type

Category:

Cross-Site Scripting (XSS)

CWE:

CWE-20, CWE-79

Impact:

Arbitrary JavaScript Execution in Victim Browser

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 versions prior to 0.70.0 contain a reflected cross-site scripting (XSS) vulnerability where unvalidated user input in the categoryUpdated parameter can be rendered directly in the browser.

If an attacker can convince a user to visit a crafted URL, they may execute arbitrary JavaScript in the victim's browser within the Movary origin, potentially leading to account takeover or data exposure.

Affected context

The vulnerability occurs in Movary's web interface when handling HTTP requests that include the ?categoryUpdated= query parameter.

Affected instances are those running versions prior to 0.70.0 where the parameter value is reflected back into the page without robust sanitization or output encoding.

The issue becomes especially impactful in authenticated browser sessions, where injected scripts can interact with user data and session context.

Exploit preconditions

  • Attack surface: Public web interface of Movary
  • Required access: Ability to send or host a malicious link pointing to a vulnerable Movary instance
  • Victim requirements: A user must open the crafted URL in a browser where they have access to Movary (often while logged in)
  • Trigger point: Server-side rendering or client-side DOM update that reflects categoryUpdated into the response without proper encoding
  • Why exploitation is possible: Insufficient input validation (CWE-20) and lack of context-appropriate output encoding allow attacker-controlled data to be interpreted as active script content

Why this happens

The core issue aligns with CWE-79: Improper Neutralization of Input During Web Page Generation (Cross-site Scripting).

Movary reflects the categoryUpdated query parameter into an HTML or script context without consistently neutralizing special characters or applying context-aware output encoding (e.g., HTML, attribute, or JavaScript encoding).

Combined with CWE-20: Improper Input Validation, the application trusts and processes user-controllable data without constraining allowed characters or patterns, enabling crafted payloads to break out of the intended data context and execute as JavaScript in the victim's browser.

Potential impact

  • Execution of arbitrary JavaScript in the victim's browser under the Movary origin
  • Theft or misuse of session cookies or tokens, where browser protections permit
  • Unauthorized actions performed on behalf of the user (e.g., changing data, modifying lists, or ratings)
  • Exfiltration or manipulation of a user's movie history and related personal preferences
  • Use of the vulnerable Movary instance as a pivot to deliver further browser-based attacks (e.g., phishing overlays)

General mitigation guidance

Effective mitigation focuses on breaking the path from user-controlled input to executable browser contexts.

Common defensive patterns include:

  • Applying strict, context-aware output encoding for all reflected data (HTML, attribute, JavaScript, and URL contexts)
  • Validating and constraining inputs like categoryUpdated to a known-safe set of values (e.g., an allowlist of expected categories or status codes)
  • Centralizing template rendering through a framework that defaults to auto-escaping output
  • Avoiding direct insertion of raw query parameters into HTML or script blocks
  • Implementing Content Security Policy (CSP) to reduce the impact of any residual XSS issues
  • Minimizing use of inline event handlers or dynamically built HTML where possible

How teams detect issues like this

Detection can combine automated and manual techniques:

  • Static analysis: Scan server-side templates and handlers for direct interpolation of request parameters like categoryUpdated without encoding functions.
  • Dynamic testing: Use automated web scanners and fuzzers configured to inject XSS payloads into query parameters and inspect responses for reflected content.
  • Code review signals: Look for $_GET, query parameter access, or routing handlers that read categoryUpdated and write it directly into responses.
  • Security testing policies: Integrate XSS test cases into CI pipelines, with checks for unsafe string concatenation in views and client-side scripts.
  • Logging and monitoring: Track unusual or long query strings and error responses that might indicate probing for XSS, though this is more useful for detecting attempts than prevention.

Sources

SourceLink
github.comgithub.com/leepeuker/movary/blob/main/public/js/settings-account-location.js#L237
github.comgithub.com/leepeuker/movary/releases/tag/0.70.0
github.comgithub.com/leepeuker/movary/security/advisories/GHSA-v32w-5qx7-p3vq

Frequently asked

questions

Yes. An attacker can exploit the issue remotely by crafting a malicious URL and getting a victim to open it in a browser that can access the vulnerable Movary instance.

The attack payload itself does not require attacker authentication, but the impact is greatest when the victim is authenticated to Movary, because injected scripts then execute with that user's privileges and data access.

Apply strict, context-aware output encoding whenever reflecting user input, and constrain the categoryUpdated parameter to a small set of allowed values. Use templating frameworks that auto-escape content by default rather than manually concatenating untrusted data into HTML or script contexts.

Adopt a defense-in-depth strategy: enforce robust input validation, treat all client-provided data as untrusted, rely on auto-escaping templating engines, incorporate XSS-focused security checks into code review and CI pipelines, and deploy a strong Content Security Policy to limit the damage of any remaining issues.

Find out what's already
exploitable in your codebase.