/

CVE-2026-32734

Severity:

HIGH RISK

(7.1)

Cross-Site Scripting (XSS) in baserCMS Tag Creation

CVE-2026-32734

Analyzed

Vulnerability type

Category:

Cross-Site Scripting (XSS)

CWE:

CWE-79

Impact:

Client-Side Code Execution / Session Compromise

Severity:

HIGH RISK

(7.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

baserCMS contained a DOM-based cross-site scripting (XSS) vulnerability in its tag creation functionality, allowing attacker-controlled data in the browser to be reflected into the page DOM without proper sanitization.

Under typical deployment conditions, this can enable execution of arbitrary JavaScript in a victim's browser when they interact with maliciously crafted tag creation inputs or URLs.

Affected context

The vulnerability occurs in the tag creation features of baserCMS when user-controlled values are processed in the browser and written back into the DOM.

It is relevant in contexts where administrators, editors, or other privileged users access tag creation pages that handle data derived from URL parameters, form inputs, or stored content without robust client-side encoding.

The issue manifests when JavaScript in the page manipulates these values and injects them into the DOM using unsafe APIs (e.g., innerHTML) instead of using safe, text-only properties.

Exploit preconditions

  • Attack surface: Web interface of baserCMS, specifically tag creation views or related pages rendered in a browser.
  • Required access: Ability to cause a user (often an authenticated admin/editor) to visit or interact with a crafted URL, form, or page content that influences tag creation logic.
  • User interaction: A victim must load or act on the crafted page in their browser (e.g., clicking a link, opening a management screen, or using tag creation forms).
  • Trigger point: Client-side JavaScript reads untrusted data and writes it into the DOM without appropriate encoding or sanitization.
  • Why exploitation is possible: The DOM update logic treats attacker-controlled strings as HTML or script-capable content, rather than as inert text, enabling script execution.

Why this happens

This vulnerability is rooted in DOM-based XSS, where client-side code manipulates attacker-controlled values and injects them into the DOM using unsafe sinks.

Instead of applying contextual HTML/JavaScript encoding or using text-only DOM methods, the tag creation logic relies on APIs that interpret the input as HTML, causing embedded script payloads to execute.

This aligns with CWE-79: Improper Neutralization of Input During Web Page Generation (Cross-Site Scripting), specifically the DOM-based variant, where the vulnerability exists in the browser rather than purely in server-side templates.

Potential impact

  • Execution of arbitrary JavaScript in the context of the baserCMS origin.
  • Theft of session identifiers, CSRF tokens, or other sensitive data accessible to the page.
  • Unauthorized actions performed on behalf of privileged users (e.g., content changes, user management) via session hijacking or in-browser request forgery.
  • Defacement of site content or injection of malicious content for downstream users.
  • Use of the affected site as a pivot for further client-side attacks (e.g., browser exploitation, phishing overlays).

General mitigation guidance

Effective mitigation focuses on treating all client-influenced data as untrusted and enforcing strict output encoding at the point it enters the DOM.

Recommended patterns include:

  • Refactoring client-side code to use text-only DOM APIs (e.g., textContent, innerText, safe attribute setters) instead of innerHTML or equivalent HTML-parsing sinks.
  • Applying context-aware encoding on any data derived from user input, query parameters, or stored content when it is rendered within HTML, attributes, or JavaScript contexts.
  • Limiting the amount of logic that runs in the browser and centralizing HTML generation on the server where consistent output encoding frameworks can be used.
  • Adopting a content security policy (CSP) that disallows inline scripts and restricts script sources to reduce XSS exploitability.
  • Applying the principle of least privilege in UI design so that the most sensitive actions are not easily reachable from potentially tainted views.

How teams detect issues like this

Detection tends to combine code-level review with automated scanning:

  • Static analysis: Flag usage of dangerous sinks (e.g., innerHTML, document.write, jQuery .html()) in client-side code when they are fed by data originating from location, document.referrer, localStorage, or unvalidated server responses.
  • Manual code review: Examine tag creation modules and related JavaScript for patterns where input is read from URL parameters, form fields, or AJAX responses and directly placed into the DOM without encoding.
  • Dynamic application security testing (DAST): Use web scanners configured for DOM-based XSS to exercise tag creation flows with reflective payloads and analyze the browser runtime behavior.
  • CI/CD policies: Enforce pre-merge checks that block introduction of new unsafe DOM sinks or require justification and security review when such APIs are used.

Sources

SourceLink
basercms.netbasercms.net/security/JVN_20837860
github.comgithub.com/baserproject/basercms/releases/tag/5.2.3
github.comgithub.com/baserproject/basercms/security/advisories/GHSA-677c-xv24-crgx

Frequently asked

questions

Exploitability depends on who can influence the data feeding the tag creation logic and who visits the affected pages; if attackers can get privileged users to load crafted URLs or content, the vulnerability can have significant impact.

Not necessarily. In many scenarios, the attacker only needs to convince an authenticated administrator or editor to interact with a crafted link or page where the untrusted data reaches the vulnerable DOM sink.

The most reliable pattern is to eliminate unsafe DOM writes by using text-only DOM APIs combined with consistent, context-aware output encoding for any data that might be influenced by users or external inputs.

Prevention hinges on a secure coding standard for front-end development: treat all client-side data as untrusted, avoid HTML-injecting APIs, enforce CSP, and integrate static and dynamic XSS checks into the regular development and review process.

Find out what's already
exploitable in your codebase.