/

CVE-2026-22867

Severity:

HIGH RISK

(8.7)

XSS in LaSuite Doc Interlinking Feature

CVE-2026-22867

Analyzed

Vulnerability type

Category:

Cross-Site Scripting (XSS)

CWE:

CWE-79

Impact:

Stored Cross-Site Scripting leading to arbitrary JavaScript execution in users' browsers

Severity:

HIGH RISK

(8.7)

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

A stored Cross-Site Scripting (XSS) vulnerability in LaSuite Doc's interlinking feature allows attackers to embed malicious javascript: links inside documents.

When other users click these crafted links, arbitrary JavaScript executes in their browser within the context of the LaSuite Doc application, potentially leading to account compromise and data exposure.

Affected context

This issue occurs in LaSuite Doc instances where:

  • The interlinking feature is used to create links to other documents from within the editor.
  • The URL field for inter-document links is accepted and stored without sufficient validation or restriction of URL schemes.
  • Users with document editing privileges can save links that are later rendered and clicked by other users.

The risk is higher in shared workspaces where many users routinely follow internal document links.

Exploit preconditions

  • Attack surface: Web UI of LaSuite Doc, specifically the document editor and rendered document view.
  • Required access: Ability to edit or create documents (authenticated user with document editing privileges).
  • Trigger point: A victim user viewing a document and clicking on a malicious link created via the interlinking feature.
  • Why exploitation is possible: The application stores link URLs and renders them as clickable anchors without validating or restricting dangerous URL schemes such as javascript:, allowing attacker-controlled scripts to run in the victim's browser.

Why this happens

The vulnerability stems from insufficient validation and sanitization of user-supplied link URLs in the interlinking feature.

Instead of enforcing a safe set of URL schemes (e.g., https, http, relative links) or stripping script-executable protocols, the application stores and renders whatever the editor provides.

This aligns with CWE-79: Improper Neutralization of Input During Web Page Generation (Cross-Site Scripting), where untrusted content is included in a web page in a way that the browser interprets as executable script.

The stored nature of the issue means malicious links persist in the document and affect multiple users over time.

Potential impact

  • Theft of session tokens or other sensitive data accessible via the DOM or application APIs.
  • Impersonation of users by performing actions on their behalf (e.g., editing, sharing, or deleting documents).
  • Injection of fake content or phishing interfaces within the application UI.
  • Lateral movement by spreading additional malicious links to other users and documents.
  • Potential exfiltration of confidential documentation or wiki content accessible to the victim.

General mitigation guidance

Effective mitigation typically focuses on enforcing strict output encoding and URL validation rules around user-controlled links:

  • Restrict allowed URL schemes for inter-document links to a safe allowlist (e.g., https, http, and internal relative paths), and reject or neutralize any javascript:, data:, or other script-capable schemes.
  • Apply context-appropriate output encoding when rendering user-supplied link attributes, ensuring the browser treats them as data rather than executable code.
  • Normalize and validate URLs server-side before persisting them to storage, so invalid or unsafe URLs never become part of the rendered content.
  • Consider providing a safe, framework-level link creation utility that centralizes URL validation and encoding instead of duplicating logic per feature.
  • Implement least-privilege design for document editing roles, limiting who can create or modify links in sensitive documentation spaces.

How teams detect issues like this

Organizations can detect and monitor for similar vulnerabilities using a combination of review and automation:

  • Static analysis: Look for code paths that take user input and directly construct <a> tags or href attributes without URL scheme validation or encoding.
  • Code review signals: Pay special attention to features that allow editors to embed or customize links, especially where the logic directly concatenates or injects URLs into templates.
  • Content scanning: Periodically scan stored documents for suspicious patterns such as javascript: or data: URLs within link attributes, and flag or quarantine affected documents.
  • Security testing: Use dynamic application security testing (DAST) and manual penetration tests to probe link creation workflows for the ability to store and execute script-based URLs.
  • Policy enforcement: Introduce CI/CD checks or linting rules that forbid unsafe link handling patterns and require the use of approved helper functions for link rendering.

Sources

SourceLink
github.comgithub.com/suitenumerique/docs/commit/e807237dbedbc189230296b81c3aeccc1c04fa77
github.comgithub.com/suitenumerique/docs/releases/tag/v4.4.0
github.comgithub.com/suitenumerique/docs/security/advisories/GHSA-4rwv-ghwh-9rv6

Frequently asked

questions

Yes. Any attacker who can authenticate and obtain document editing rights in a vulnerable LaSuite Doc instance can embed malicious links. Other users only need to click these links while logged in for the attack to succeed.

The attacker must have document editing privileges within the application. They do not need administrative rights; a regular user who can create or modify documents in a shared space may be sufficient.

Enforce strict URL scheme validation and context-aware output encoding for all user-supplied links. Centralize link creation through a trusted helper that only permits safe protocols and automatically encodes attributes before rendering.

Adopt a secure development lifecycle that treats all rich-text and linking features as untrusted input paths, incorporates security-focused code reviews, leverages automated scanners for XSS patterns, and standardizes on hardened components for URL processing and HTML rendering.

Find out what's already
exploitable in your codebase.