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-84371

CVE-2026-84371: Stored XSS via SVG SMIL URI-list Scheme-Policy Bypass in sanitize-html

Alon Barad
Alon Barad
Software Engineer

Sep 2, 2026·5 min read·63 visits

Executive Summary (TL;DR)

SVG SMIL animation tags allow bypass of sanitize-html's scheme filtering via semicolon-separated lists in 'values' attributes, leading to arbitrary JavaScript execution.

A stored Cross-Site Scripting (XSS) vulnerability exists in sanitize-html from version 1.9.0 up to 2.17.6. The flaw permits attackers to bypass scheme-policy enforcement using SVG SMIL animation elements targeting URL attributes with semicolon-separated URI lists.

Vulnerability Overview

The library sanitize-html is designed to parse and clean untrusted HTML input, neutralizing script execution vectors while allowing safe tags and attributes to persist. In applications handling user-generated content, rich-text features often allow a subset of SVG tags to enable vector illustrations or animated graphics.

SVG Synchronized Multimedia Integration Language (SMIL) elements, such as <animate> or <set>, present a unique challenge to static sanitizers. These elements allow dynamic manipulation of DOM attributes of parent or sibling tags directly inside the browser's XML rendering engine.

When sanitize-html is configured to allow certain SVG animation elements, it exposes an attack surface where client-side state transitions can alter attributes after sanitization. By abusing this dynamic state transition, attackers can craft payloads that bypass standard URI scheme policies.

Root Cause Analysis

The underlying vulnerability arises from how the sanitization library evaluates complex attribute values compared to how web browsers render them at runtime.

Standard HTML attributes like href hold a single URL value, which the sanitizer evaluates as a flat string. If sanitize-html encounters an anchor or SVG link attribute, it checks whether the URI scheme starts with a safe scheme such as http, https, or # (relative fragment).

In the SVG SMIL specification, elements use the values attribute to specify a transition path. When the attributeName of an <animate> tag is set to href, the values attribute takes a semicolon-separated list of target URIs (e.g., values="#safe;javascript:alert(1)").

During sanitization, the parser evaluates the entire values string as a single, flat URL structure. Since the string begins with the allowed fragment character #, the library's scheme validator rules it safe and retains the attribute. Upon browser rendering, the client engine splits the semicolon-separated list and eventually executes the dynamic write of the subsequent javascript: URI into the host element's live href sink, bypassing the sanitization layer completely.

Code Analysis

To understand the implementation flaw, we examine the behavioral difference between the vulnerable code path and the patched implementation.

In vulnerable versions of the library, attributes such as values were evaluated on a per-attribute level based on basic regex or scheme matching logic. The library lacked the context that the value in the values attribute would eventually be written to a target URL sink defined by attributeName.

In the patched version (2.17.7), the maintainers introduced the animatesUrlAttribute helper function. This helper intercepts incoming SVG SMIL elements (animate, animatecolor, animatemotion, animatetransform, set) and inspects their target configuration:

function animatesUrlAttribute(name, attribs) {
  if (svgAnimationTags.indexOf(name.toLowerCase()) === -1) {
    return false;
  }
  const schemeCheckedAttributes = options.allowedSchemesAppliedToAttributes || [];
  return Object.keys(attribs || {}).some(function(attributeName) {
    if (attributeName.toLowerCase() !== 'attributename') {
      return false;
    }
    const target = (attribs[attributeName] || '').trim().toLowerCase();
    const localName = target.slice(target.lastIndexOf(':') + 1);
    return alwaysUrlAttributes.indexOf(localName) !== -1 ||
      schemeCheckedAttributes.indexOf(target) !== -1 ||
      schemeCheckedAttributes.indexOf(localName) !== -1;
  });
}

If the parser detects that an animation element is targeting a URL-bearing attribute (like href or a custom configured scheme attribute), the validator immediately discards the entire element rather than trying to sanitize the complex value lists.

Exploitation & Attack Flow

Exploitation of this vulnerability requires that the target application has enabled SVG and SMIL animation tags in its configuration. When these conditions are met, the attack can be executed using a stored XSS vector.

An attacker crafts a payload where an anchor element wraps a SMIL animation. The animation element targets the href attribute and passes a semicolon-separated list where the initial entry matches a benign destination, while the second entry contains the malicious payload:

<svg>
  <a>
    <animate attributeName="href" values="#safe;javascript:alert(document.domain)" dur=".01s" fill="freeze"></animate>
    <text y="30">Click to trigger action</text>
  </a>
</svg>

When the browser parses this structure, the SMIL engine triggers the animation. Because dur is set to .01s and fill is set to freeze, the parent anchor tag's href attribute is permanently rewritten to javascript:alert(document.domain) almost instantly. Clicking the text triggers the script immediately in the victim's session context.

Impact Assessment

The impact of this vulnerability depends heavily on the execution environment and context of the web application. Stored XSS typically allows attackers to execute arbitrary JavaScript in the context of authenticated sessions of other users.

In web portals, CMS platforms, or message boards where high-privilege users (such as administrators or content managers) interact with content, this flaw could allow an attacker to hijack active sessions, extract sensitive access tokens, or perform actions on behalf of other users.

The vulnerability is classified under CWE-79 (Cross-site Scripting). While the CVSS score is assigned as 5.4, the impact is bound by the fact that the application must explicitly allow SVG elements in its configuration, limiting the exploitability on default out-of-the-box configurations.

Remediation and Defense-in-Depth

The primary remediation for this vulnerability is to upgrade the sanitize-html library to version 2.17.7 or higher, which handles SMIL animation components safely.

For applications that are unable to apply the package upgrade immediately, several defense-in-depth measures can be deployed to block this vector. The most effective mitigation is to review the allowedTags parameter in your sanitize-html configuration and ensure that SMIL tags like animate, animatecolor, animatemotion, animatetransform, and set are excluded from the allowed list.

Additionally, implementing a strict Content Security Policy (CSP) that restricts inline script execution (script-src 'self') will block the execution of the injected javascript: URI even if it successfully bypasses the sanitization parser.

Fix Analysis (2)

Technical Appendix

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

Affected Systems

sanitize-html

Affected Versions Detail

Product
Affected Versions
Fixed Version
sanitize-html
apostrophecms
>= 1.9.0, < 2.17.72.17.7
AttributeDetail
CWE IDCWE-79
Attack VectorNetwork (AV:N)
CVSS Severity Score5.4 (Medium)
Exploit Statuspoc
CISA KEV StatusNot Listed
ImpactStored Cross-Site Scripting (XSS)

MITRE ATT&CK Mapping

T1189Drive-by Compromise
Initial Access
T1185Browser Session Hijacking
Collection
CWE-79
Cross-site Scripting

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

Known Exploits & Detection

GitHub Security AdvisoryOfficial advisory with detailed explanation of SVG SMIL bypass

References & Sources

  • [1]Official GitHub Security Advisory
  • [2]Upstream Fix Commit (Branch Integration)
  • [3]Upstream Fix Commit (Reconciliation & Release)
  • [4]Official Pull Request
  • [5]Changelog Documentation

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

•2 days ago•CVE-2026-16454
4.3

CVE-2026-16454: Object-Level Authorization Bypass in Eclipse hawkBit Direct Device Integration Controller

CVE-2026-16454 is an object-level authorization bypass vulnerability (CWE-284, CWE-862) in Eclipse hawkBit versions 1.0.3 and prior. The flaw exists within the Direct Device Integration (DDI) REST controller (hawkbit-ddi-resource), where endpoints responsible for enumerating software module metadata and serving firmware binaries fail to verify whether the requested software module is assigned to the authenticated device. Consequently, any device with valid credentials (such as a TargetToken or GatewayToken) can enumerate software module identifiers and download arbitrary firmware artifacts across the entire tenant namespace.

Amit Schendel
Amit Schendel
10 views•9 min read
•2 days ago•CVE-2026-62284
8.6

CVE-2026-62284: Remote Code Execution and SSRF via Unsanitized Kubeconfig in OSAC Operator

CVE-2026-62284 (GHSA-5w5g-j6hw-6p8f) is a code injection and server-side request forgery vulnerability in the console-proxy component of the OSAC Operator. The RemoteConfigResolver parses Kubernetes Secrets containing kubeconfig files via clientcmd.RESTConfigFromKubeConfig without sanitizing execution-related fields. An attacker with RBAC permissions to create or modify labeled Secrets in monitored namespaces can supply a malicious exec credential plugin, resulting in arbitrary command execution within the console-proxy pod.

Amit Schendel
Amit Schendel
8 views•8 min read
•2 days ago•CVE-2026-62361
5.5

CVE-2026-62361: Authenticated SQL Injection and Table Access Control Bypass in Listmonk Subscriber Export

CVE-2026-62361 (GHSA-xgjr-7j9q-2h4r) is an authenticated SQL injection and authorization bypass vulnerability in listmonk, an open-source, self-hosted newsletter and mailing list manager written in Go. In versions prior to 6.2.0, the subscriber export endpoint (GET /api/subscribers/export) directly interpolates user-supplied SQL filter expressions into a PostgreSQL query without invoking the table allowlist validation function (validateQueryTables). Consequently, authenticated users possessing the subscribers:sql_query and subscribers:get_all permissions can bypass relational access controls, execute arbitrary subqueries against restricted tables such as users and settings, and modify database state via writable Common Table Expressions (CTEs).

Alon Barad
Alon Barad
9 views•11 min read
•2 days ago•CVE-2026-28385
5.0

CVE-2026-28385: Server-Side Request Forgery in Canonical LXD Image Import

CVE-2026-28385 (GHSA-3gq2-x4qg-p4g6) is a Server-Side Request Forgery (SSRF) vulnerability in Canonical LXD versions 4.12 through 6.9. An authenticated user possessing the can_create_images entitlement can force the LXD daemon to execute arbitrary outbound HTTP and HTTPS requests via the /1.0/images API endpoint. Due to the absence of egress destination validation, an attacker can probe host loopback services, RFC 1918 private network segments, and cloud Instance Metadata Services (IMDS) from the network position of the privileged LXD daemon.

Amit Schendel
Amit Schendel
10 views•9 min read
•2 days ago•GHSA-9J25-MM2H-2F76
9.9

CVE-2026-48750: Arbitrary File Write on Host via exec-output Symlink in Canonical LXD and Incus

Canonical LXD and LXC Incus contain an arbitrary file write vulnerability (CWE-73 / CWE-59) in the `/1.0/instances/<name>/exec` REST API endpoint. When an instance is unpacked from an image archive, top-level symbolic links are extracted directly onto the host filesystem within the instance storage directory. If a crafted image includes a symbolic link named `exec-output` pointing to an arbitrary host path, invoking the execution endpoint with `record-output: true` causes the privileged host daemon to follow the symlink and write command output files directly to the target host directory. An authenticated attacker with permissions to import images and execute commands can exploit this flaw to write controlled content to sensitive host directories such as `/etc/cron.d`, resulting in arbitrary code execution on the host as `root`.

Alon Barad
Alon Barad
8 views•12 min read
•2 days ago•GHSA-VGHH-5RFX-XHQ8
9.9

CVE-2026-48749: Arbitrary Host File Read and Write via Malicious Image Symlink in Canonical LXD and Incus

CVE-2026-48749 (tracked as GHSA-vghh-5rfx-xhq8 for LXD and GHSA-2q3f-q5pq-g8wv for Incus) is a critical container escape vulnerability in the Canonical LXD and Linux Containers Incus system container managers. By importing a specially crafted container image archive containing duplicate tar member headers, an authenticated attacker can replace the instance rootfs directory with a symbolic link pointing to the underlying host root filesystem. When performing file operations on a stopped container, the privileged forkfile helper binary resolves the symbolic link without confinement and chroots directly into the host filesystem, granting arbitrary root-level file read and write access.

Amit Schendel
Amit Schendel
8 views•9 min read