/

CVE-2026-73042

Severity:

CRITICAL RISK

(9.0)

Stored XSS (CWE-79) in SiYuan Database Menu Interfaces

CVE-2026-73042

Deferred

Vulnerability type

Category:

Stored Cross-Site Scripting

CWE:

CWE-79

Impact:

Arbitrary Script Execution and Potential Desktop Privilege Abuse

Severity:

CRITICAL RISK

(9.0)

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

SiYuan contains a stored cross-site scripting vulnerability in database menu metadata because user-controlled names and descriptions are not properly escaped during HTML interpolation. When a user opens affected group, view, or field-edit menus, injected markup may execute script and, in Electron deployments with insecure settings, potentially access Node.js capabilities.

Affected context

The issue occurs in SiYuan database interfaces that render stored metadata into HTML without adequate context-aware escaping. It becomes risky when an attacker can create or modify database field names or descriptions and another user opens a related group, view, or field-edit menu. The impact may be greater in Electron environments where renderer processes have access to privileged Node.js or application capabilities.

Exploit preconditions

  • Attack surface: SiYuan database menu rendering in the desktop or web application
  • Required access: Ability to create or modify database metadata, such as field names or descriptions
  • Trigger point: A victim opens a group, view, or field-edit menu containing the stored value
  • Why exploitation is possible: User-controlled metadata is interpolated into HTML without sufficient escaping, allowing markup and event-handler content to be interpreted as executable script
  • Environmental factor: Electron security configuration and exposed application bridges may determine whether script execution can reach Node.js or other privileged functionality

Why this happens

The underlying bug is context-insensitive output encoding of untrusted database metadata. Values are inserted into HTML in a way that permits attacker-controlled markup to terminate containing elements or introduce executable event-handler attributes.

This behavior maps to CWE-79: Improper Neutralization of Input During Web Page Generation ('Cross-site Scripting'). The risk is amplified when a desktop application's renderer has excessive privileges, because a renderer-level script injection may extend beyond ordinary browser page manipulation.

Potential impact

  • A malicious value may execute arbitrary script when a vulnerable menu is opened.
  • An attacker could alter visible application content or perform actions in the victim's session.
  • Session data or application information may be exposed.
  • In an insecurely configured Electron runtime, script execution could reach Node.js built-ins or other privileged APIs.
  • Data integrity could be affected through unauthorized database or workspace actions.

General mitigation guidance

Mitigation generally focuses on treating all database metadata as untrusted and enforcing output encoding at every rendering context.

Common defensive patterns include:

  • Apply context-aware HTML escaping or safe DOM construction before inserting names and descriptions.
  • Prefer text-node APIs and trusted component rendering over raw HTML interpolation.
  • Sanitize markup only when a documented formatting requirement exists, using a narrowly allowlisted policy.
  • Keep renderer processes isolated from Node.js and expose only minimal, capability-scoped application bridges.
  • Use secure Electron defaults, including strong context isolation and disabled renderer Node integration where feasible.
  • Validate and constrain metadata at input boundaries without relying on validation as a substitute for output encoding.
  • Apply least privilege to application services and workspace operations.

How teams detect issues like this

Detection can combine source review, automated analysis, and runtime testing:

  • Search for raw HTML interpolation involving database names, descriptions, labels, or other persisted metadata.
  • Review uses of innerHTML, HTML template construction, unsafe rendering components, and event-handler-capable attributes.
  • Use static analysis or automated code review rules that flag unescaped user-controlled values in HTML contexts.
  • Add regression tests containing benign markup-like strings to verify that output is rendered as text rather than interpreted as HTML.
  • Inspect Electron configuration for Node integration, context isolation, preload exposure, and unrestricted IPC bridges.
  • Enforce content security and renderer-isolation policies through CI checks and application security reviews.

Sources

SourceLink
github.comgithub.com/siyuan-note/siyuan/security/advisories/GHSA-gcm3-qcq3-72rv
vulncheck.comvulncheck.com/advisories/siyuan-before-remote-code-execution-via-menu-metadata

Frequently asked

questions

Exploitability depends on how database metadata is created or synchronized. An attacker generally needs a way to place crafted names or descriptions into a shared or otherwise accessible SiYuan workspace, after which another user must open the affected menu.

Not necessarily. The relevant prerequisite is permission to create or modify the stored metadata, although application sharing and workspace permissions determine who has that capability.

Render database metadata as text using context-aware output encoding and avoid raw HTML interpolation. Electron deployments should also isolate renderers and minimize exposed privileged APIs.

Treat persisted metadata as untrusted input, use secure DOM APIs, test every rendering context for injection, and enforce Electron security policies through code review and automated CI checks.

Find out what's already
exploitable in your codebase.