Nov 17, 2026·9 min read·0 visits
An incomplete MIME type denylist in Silverstripe Framework's XssSanitiser allows authenticated CMS authors to bypass HTML sanitization using data:application/xhtml+xml, data:text/xml, and data:application/xml URIs, resulting in stored Cross-Site Scripting (XSS). Upgrade to silverstripe/silverstripe-framework 6.2.13 to remediate the flaw.
CVE-2026-88987 (GHSA-qqrg-8jpm-8mph) is a stored Cross-Site Scripting (XSS) vulnerability in the Silverstripe Framework prior to version 6.2.13. The framework's HTML sanitization engine, XssSanitiser, relies on an incomplete regular expression denylist when filtering URI schemes in HTML attributes. Specifically, the sanitizer strips data:text/html URIs but fails to restrict executable XML and XHTML media types such as data:application/xhtml+xml, data:text/xml, and data:application/xml. An authenticated user with content creation privileges can embed crafted data URIs inside HTML attributes like iframe src or object data, leading to arbitrary JavaScript execution when the content is rendered by a victim's browser.
The Silverstripe Framework (silverstripe/silverstripe-framework) serves as the core architectural foundation for the Silverstripe Content Management System (CMS). In standard CMS workflows, authenticated content authors and editors submit rich text and HTML fragments through the backend administration interface. Before this content is persisted to the database or rendered in page templates, the framework passes the markup through SilverStripe\Core\XssSanitiser to strip executable script elements and dangerous attributes.
In versions prior to 6.2.13, XssSanitiser exhibits a sanitization bypass tracked as CVE-2026-88987 (GHSA-qqrg-8jpm-8mph) and classified under CWE-79 (Improper Neutralization of Input During Web Page Generation). The sanitizer inspects URI-bearing HTML attributes—such as src, href, data, and lowsrc—against a regular expression denylist to prevent the injection of executable schemes like javascript: and data:text/html. However, the denylist omits XML-based media types that modern web browsers parse as executable document trees.
An authenticated user with low privileges (such as a CMS content author) can exploit this omission by injecting data: URIs specifying application/xhtml+xml, text/xml, or application/xml media types into allowed HTML elements like <iframe> or <object>. Because these MIME types do not match the data:text/html pattern, the sanitizer leaves the attribute intact.
When another CMS administrator or site visitor views the stored record or previews the draft page, the browser parses the inline XML/XHTML document. If the payload declares the standard XHTML namespace (http://www.w3.org/1999/xhtml), the browser engine instantiates and executes any embedded <script> elements within the context of the parent origin or child browsing context.
The root cause of CVE-2026-88987 resides in src/Core/XssSanitiser.php, specifically within the getStripAttributeContentsRegex() and splitWithWhitespaceRegex() private methods. When XssSanitiser processes an HTML document, it invokes stripAttributeContents() to evaluate whether an attribute value begins with a dangerous URI scheme or media type. If a match occurs, the attribute is stripped from the DOM node.
Prior to version 6.2.13, getStripAttributeContentsRegex() constructed its filtration pattern from only three string literals: javascript:, data:text/html, and vbscript:. This denylist approach assumes that text/html is the sole MIME type capable of triggering script execution within a data: URI. In practice, all major browser rendering engines (Blink, Gecko, and WebKit) support full DOM construction and script execution for XML media types when the root or child elements bind to the XHTML namespace.
Specifically, when a browser loads a data:application/xhtml+xml, data:text/xml, or data:application/xml URI containing <html xmlns="http://www.w3.org/1999/xhtml"><script>...</script></html>, the XML parser delegates element handling to the HTML/XHTML DOM implementation. Upon encountering the <script> tag within the XHTML namespace, the browser executes the enclosed JavaScript payload. Noticeably, prior to the patch, the framework's own unit test suite in HTMLEditorSanitiserTest.php explicitly asserted that data:text/xml content inside an <object data="..."> attribute should be preserved (keep text/xml content in data attribute), demonstrating a flawed assumption regarding the safety of XML media types.
A secondary flaw existed in splitWithWhitespaceRegex(string $string), which converts a target string into a regular expression pattern that tolerates arbitrary whitespace or invisible characters between letters. The method split the input string into individual characters via str_split($string) and joined them with \s* without escaping regular expression metacharacters:
return implode('\s*', str_split($string));When a media type containing a regex metacharacter—such as the + sign in application/xhtml+xml—was passed into splitWithWhitespaceRegex(), the + was emitted directly into the pattern as \s*+\s*. In PCRE, an unescaped + acts as a possessive quantifier or repetition operator rather than matching a literal plus character (0x2B), causing either regex compilation errors or failure to match literal application/xhtml+xml strings.
The vulnerability was resolved in commit cea9c46eba4be31a06adf6980494623385e1296d (Pull Request #12039). The patch modifies src/Core/XssSanitiser.php in two places: expanding the array of disallowed URI prefixes and escaping individual characters during regex generation.
// File: src/Core/XssSanitiser.php
private function getStripAttributeContentsRegex(): string
{
$regexes = [
$this->splitWithWhitespaceRegex('javascript:'),
// Data URIs whose MIME type is rendered as a scriptable document can execute JavaScript
// (e.g. inline <script> in an XHTML document), so they must be blocked just like data:text/html.
// An XML document whose root element is in the XHTML namespace is parsed as XHTML regardless
// of which of these XML media types declares it, so all three are equally exploitable.
$this->splitWithWhitespaceRegex('data:text/html'),
$this->splitWithWhitespaceRegex('data:application/xhtml+xml'), // Added: Block XHTML MIME type
$this->splitWithWhitespaceRegex('data:text/xml'), // Added: Block text/xml MIME type
$this->splitWithWhitespaceRegex('data:application/xml'), // Added: Block application/xml MIME type
$this->splitWithWhitespaceRegex('vbscript:'),
];
// Regex is "starts with any of these, with optional whitespace at the start, case insensitive"
return '#^\s*(' . implode('|', $regexes) . ')#iu';
}
private function splitWithWhitespaceRegex(string $string): string
{
// Note that `\s` explicitly includes ALL invisible characters when used with the `u` modifier.
// That includes unicode characters like the non-breaking space.
// Each character is escaped so regex-special characters (e.g. the `+` in a MIME type) are
// matched literally rather than treated as quantifiers.
$chars = array_map(fn (string $char): string => preg_quote($char, '#'), str_split($string));
return implode('\s*', $chars);
}In splitWithWhitespaceRegex(), wrapping each character in preg_quote($char, '#') ensures that the + in application/xhtml+xml is transformed into \+. When joined with \s* and evaluated under the #iu (case-insensitive, UTF-8) modifiers, the compiled pattern accurately matches variations containing interspersed spaces, newlines, or control characters while treating regex operators as literal characters.
Regarding fix completeness, the patch addresses the three standard XML and XHTML MIME types recognized by browsers for document rendering, while preserving benign data: URIs such as data:image/png;base64,.... However, the architecture remains reliant on a denylist of dangerous MIME types (data:text/html, data:application/xhtml+xml, data:text/xml, data:application/xml) rather than an explicit allowlist of safe data: media types (such as image/png, image/jpeg, image/gif, image/webp). If additional script-capable media types such as data:image/svg+xml are permitted in attributes where SVG script execution is rendered by the browser (such as <iframe src> or <object data>), a denylist approach may require further additions compared to a strict scheme/MIME allowlist.
Exploiting CVE-2026-88987 requires an attacker to possess authenticated access to the Silverstripe CMS interface with permissions to author or edit HTML-enabled fields (reflected in the CVSS vector as PR:L). No special server configuration is required, as XssSanitiser and HTMLEditorSanitiser are used by default across standard Silverstripe HTMLText fields where elements like <iframe> or <object> are permitted by the editor configuration.
To execute the attack, the adversary submits raw HTML content through the CMS editor or directly via a POST request to the page saving endpoint. The attacker embeds a data: URI inside an element attribute that initiates a sub-document load. Several payload variations confirmed in the official test suite demonstrate the versatility of the bypass:
<!-- Variation 1: URL-encoded application/xhtml+xml in iframe src -->
<iframe src="data:application/xhtml+xml,%3Chtml%20xmlns%3D%22http%3A%2F%2Fwww.w3.org%2F1999%2Fxhtml%22%3E%3Cbody%3E%3Cscript%3Ealert(1)%3C%2Fscript%3E%3C%2Fbody%3E%3C%2Fhtml%3E"></iframe>
<!-- Variation 2: Base64-encoded application/xhtml+xml -->
<iframe src="data:application/xhtml+xml;base64,PHNjcmlwdD5hbGVydCgxKTwvc2NyaXB0Pg=="></iframe>
<!-- Variation 3: text/xml with explicit XHTML namespace declaration -->
<iframe src="data:text/xml,<html xmlns="http://www.w3.org/1999/xhtml"><script>alert(1)</script></html>"></iframe>
<!-- Variation 4: Base64-encoded text/xml in object data attribute -->
<object data="data:text/xml;base64,PHNjcmlwdD5hbGVydChkb2N1bWVudC5sb2NhdGlvbik8L3NjcmlwdD4="></object>
<!-- Variation 5: Whitespace obfuscation across the MIME type -->
<iframe src="d a t a : a p p l i c a t i o n / x h t m l + x m l,<script>alert(1)</script>"></iframe>When the CMS processes the submission on a vulnerable version (< 6.2.13), XssSanitiser checks the src or data attribute against getStripAttributeContentsRegex(). Because none of the payloads begin with javascript:, vbscript:, or data:text/html, the sanitizer approves the attribute and stores the markup in the database (e.g., within the SiteTree draft table).
When a higher-privileged user, such as a CMS Administrator, opens the page in the CMS preview pane or navigates to the published page on the frontend, the browser parses the <iframe> or <object> element and resolves the data: URI. The browser's XML parser recognizes the XHTML namespace and executes the embedded JavaScript.
CVE-2026-88987 is scored at 5.4 (Medium) under CVSS v3.1 with the vector CVSS:3.1/AV:N/AC:L/PR:L/UI:R/S:C/C:L/I:L/A:N. The Attack Complexity is Low (AC:L) because constructing the data: URI requires no timing dependencies or environment-specific knowledge. Privileges Required is Low (PR:L) since the attacker must first authenticate as a CMS author or editor capable of submitting HTML content, and User Interaction is Required (UI:R) because a victim must view the malicious page.
The Scope is marked as Changed (S:C) because the vulnerability resides in the server-side sanitization component, whereas the security impact manifests within the client-side web browser DOM environment. Depending on how the browser isolates the data: URI sub-document (e.g., inside an <iframe> versus an <object> tag or top-level navigation), the executed script operates within the browsing context and can interact with the user interface, perform phishing overlays, or initiate unauthorized HTTP requests.
If the injected script executes in a context that shares origin permissions or can communicate with the parent CMS window, an attacker with author privileges can escalate privileges to full CMS Administrator by hijacking administrative sessions, extracting CSRF tokens (SecurityID in Silverstripe), or silently invoking backend administrative APIs on behalf of the viewing administrator.
At the time of publication, CVE-2026-88987 is not listed in the CISA Known Exploited Vulnerabilities (KEV) catalog, and no active in-the-wild exploitation campaigns have been recorded.
To remediate CVE-2026-88987, upgrade silverstripe/silverstripe-framework to version 6.2.13 or later. Administrators managing dependencies via Composer can apply the update by executing:
composer update silverstripe/framework:^6.2.13Because this is a stored XSS vulnerability, upgrading the framework prevents new malicious payloads from passing through XssSanitiser during save operations, but it does not automatically purge payloads that were already written to the database prior to the upgrade. Security teams should audit existing database content tables (such as SiteTree, SiteTree_Live, and SiteTree_Versions) for stored XML/XHTML data: URIs:
SELECT ID, Title, ClassName
FROM SiteTree
WHERE Content LIKE '%data:%xml%';> [!NOTE]
> Because attackers can insert whitespace or newline characters between any characters of the data: URI scheme and MIME type, a simple substring SQL query may not catch obfuscated payloads. If untrusted authors had access to the CMS prior to patching, consider re-running XssSanitiser over stored HTML fields or inspecting attributes matching <iframe and <object.
For environments where immediate patching is not feasible, deploy a restrictive Content Security Policy (CSP) response header at the web server or reverse proxy layer. Specifically, restrict frame-src and object-src so that data: URIs cannot be loaded as sub-documents:
Content-Security-Policy: default-src 'self'; object-src 'none'; frame-src 'self';Setting object-src 'none' and excluding data: from frame-src instructs compliant browsers to block the rendering of data:application/xhtml+xml, data:text/xml, and data:application/xml payloads inside <object>, <embed>, and <iframe> elements even if the attribute bypasses server-side sanitization.
CVSS:3.1/AV:N/AC:L/PR:L/UI:R/S:C/C:L/I:L/A:N| Product | Affected Versions | Fixed Version |
|---|---|---|
silverstripe/silverstripe-framework Silverstripe | < 6.2.13 | 6.2.13 |
| Attribute | Detail |
|---|---|
| CVE ID | CVE-2026-88987 (GHSA-qqrg-8jpm-8mph) |
| Vulnerability Class | CWE-79: Stored Cross-Site Scripting (XSS) |
| CVSS v3.1 Score | 5.4 Medium (CVSS:3.1/AV:N/AC:L/PR:L/UI:R/S:C/C:L/I:L/A:N) |
| Affected Component | SilverStripe\Core\XssSanitiser (silverstripe/silverstripe-framework < 6.2.13) |
| Attack Vector | Authenticated HTML submission containing data:application/xhtml+xml, data:text/xml, or data:application/xml URIs |
| Patched Version | 6.2.13 |
| Exploit Status | Proof-of-Concept (Unit test payloads published in commit cea9c46eba4be31a06adf6980494623385e1296d) |
| CISA KEV Status | Not Listed |
The product does not neutralize or incorrectly neutralizes user-controllable input before it is placed in output that is used as a web page that is served to other users.
A Stored Cross-Site Scripting (XSS) vulnerability exists in Silverstripe Framework versions prior to 6.2.13 within the SilverStripe\Core\XssSanitiser component. The HTML sanitizer fails to strip SVG data URIs (data:image/svg*) from dangerous HTML attributes such as href, src, lowsrc, and data. Authenticated CMS authors can persist crafted SVG data URIs in stored content, leading to arbitrary JavaScript execution in the browser context of users who view or interact with the rendered page.
CVE-2026-88989 (tracked as GHSA-3qh3-54qg-gpq3) is a missing authorization vulnerability (CWE-862) in the Silverstripe Framework affecting versions prior to 6.2.13. The flaw exists within the GridFieldDetailForm_ItemRequest request handler, which orchestrates record creation and editing workflows inside the Silverstripe CMS backend. Specifically, the server-side persistence method saveFormIntoRecord() fails to verify whether an authenticated user possesses the necessary creation permissions (canCreate) when processing an unpersisted DataObject record. Consequently, a low-privileged CMS user who has permission to access a GridField interface and edit existing records can bypass role-based creation restrictions. By sending a crafted HTTP POST request directly to the item/new endpoint with the action_doSave parameter, the user can instantiate and persist unauthorized database records. The vulnerability is rated Medium severity with a CVSS v3.1 base score of 4.3 and is remediated in Silverstripe Framework version 6.2.13.
Silverstripe Framework prior to version 6.2.13 contains an improper privilege management vulnerability (CWE-269) within the Group authorization and validation logic. A delegated administrator possessing the CMS_ACCESS_SecurityAdmin permission, but lacking full ADMIN privileges, can edit or reparent groups that acquire administrative capabilities indirectly via permission roles or ancestor inheritance. By adding their own account to such a group or moving a controlled group underneath a role-privileged parent, the user escalates to full administrative access across the CMS.
A missing authorization and type validation vulnerability in Silverstripe Framework prior to version 6.2.13 allows authenticated CMS users to convert database records into arbitrary DataObject classes via user-controlled ClassName parameters in GridField detail forms.
CVE-2026-91115 (GHSA-c94f-87xg-65wf) is an unsafe reflection vulnerability in the Silverstripe Framework affecting versions 6.0.0 prior to 6.2.13. The built-in development task i18nTextCollectorTask passes the user-supplied 'writer' parameter directly to Silverstripe's dependency injection container (Injector::inst()->get()) without verifying that the requested class implements the expected Writer interface. Because the dependency injector supports instantiating arbitrary classes with attacker-supplied constructor arguments, and because nested task URLs bypassed interactive confirmation middleware, an attacker can achieve remote code execution via unauthenticated requests on development instances or via Cross-Site Request Forgery (CSRF) against authenticated administrators on production instances.
CVE-2026-129237 is a partial path traversal (Zip Slip) vulnerability in qbee-agent, the device agent for the qbee.io IoT device management platform. Prior to version 2026.41, the tar archive extraction routine in app/utils/tar.go used strings.HasPrefix without enforcing a directory separator boundary. When the Docker Compose bundle configuration has UseContext enabled, an authenticated user with delegated configuration or file management privileges can supply a crafted tar archive containing sibling-prefix traversal sequences, allowing directory creation and file writes into adjacent sibling directories outside the intended extraction root.