CVE-2026-6827 in justhtml
Summary
by MITRE • 08/23/2026
justhtml before 1.17.0 contains multiple security issues in sanitization, serialization, and programmatic DOM handling. When custom policies preserve foreign namespaces (SVG/MathML), dangerous content such as HTML integration points (SVG <foreignObject>, MathML <annotation-xml encoding="text/html">) and mutation-XSS parser-differential payloads could survive sanitization and become active HTML after reparse; SVG filter="url(...)" and preserved <style> could leave resource-loading CSS (@import, background-image:url()). Programmatic script/style/Comment nodes could serialize into active markup. Additional hardening fixes address sanitize-pipeline cache mutation and DOM parent/child cycles that could cause infinite loops. Most issues affect advanced or custom configurations rather than the default JustHTML(..., sanitize=True) safe path.
If you want to get the best quality for vulnerability data then you always have to consider VulDB.
Analysis
by VulDB Data Team • 08/23/2026
The vulnerability identified in justhtml versions prior to 1.17.0 represents a complex series of flaws within its sanitization engine, serialization logic, and programmatic Document Object Model handling mechanisms. These issues primarily stem from the library's ability to preserve foreign namespaces such as SVG and MathML when custom policies are configured to allow them. While this feature is intended for legitimate use cases requiring rich media integration, it introduces significant attack surfaces if not strictly constrained. The core technical flaw lies in how the sanitizer processes HTML integration points embedded within these preserved namespaces. Specifically, elements like SVG foreignObject or MathML annotation-xml with text/html encoding can act as containers that bypass standard sanitization checks. When such content is processed and subsequently reparsed by the browser's native parser, it transforms into active HTML rather than remaining inert XML data. This behavior enables attackers to inject malicious scripts or other dangerous payloads that survive the initial filtering process because they are technically valid within their respective namespaces but become executable once interpreted as standard HTML during re-parsing.
Beyond integration points, the vulnerability extends to CSS-based attack vectors facilitated by preserved SVG filter attributes and style elements. An attacker can exploit this by injecting an SVG element with a filter attribute pointing to a URL that references external resources or malicious scripts. Similarly, if <style> blocks are permitted within the sanitized output, attackers can utilize dangerous CSS properties such as @import rules or background-image:url() directives. These constructs allow for resource loading from arbitrary domains, which can be leveraged for cross-site scripting attacks through data exfiltration techniques or by triggering execution of malicious code via CSS expressions in older browsers. The serialization process further exacerbates these risks because programmatic insertion of script, style, and comment nodes into the DOM can result in their direct serialization into active markup without adequate escaping or validation. This means that even if input is sanitized at ingestion, dynamic manipulation of the DOM tree post-sanitization can reintroduce executable content into the final output stream.
The operational impact of these vulnerabilities is significant for applications relying on justhtml to process user-generated content with advanced customization options. While the default configuration using sanitize=True provides a robust defense against common injection attacks, systems employing custom policies that enable foreign namespace preservation are highly susceptible to stored and reflected cross-site scripting attacks. The ability to bypass sanitization through parser-differential payloads means that an attacker can craft input that appears safe under one parsing context but becomes dangerous in another. This is particularly relevant for web applications that render rich text content, as it allows malicious actors to execute arbitrary JavaScript code within the victim's browser session. Such execution grants full control over the user environment, including access to cookies, session tokens, and sensitive form data, leading to potential account takeover or further lateral movement within an application ecosystem.
In addition to active script injection, the vulnerability description highlights critical stability issues related to cache mutation in the sanitize pipeline and infinite loops caused by DOM parent-child cycles. These flaws represent denial-of-service risks where malformed input can cause the server-side processing thread to hang indefinitely due to recursive traversal of circular references in the DOM tree. Furthermore, mutating internal caches during sanitization could lead to inconsistent state management, potentially causing unpredictable behavior or memory exhaustion. Although these specific stability issues are distinct from code injection vectors, they contribute to an overall reduction in system reliability and availability, which is a key component of security posture under frameworks like OWASP Top 10.
To mitigate these risks, organizations must upgrade immediately to justhtml version 1.17.0 or later, where these sanitization logic errors have been addressed. For environments that require the preservation of SVG or MathML namespaces for legitimate functionality, it is imperative to implement strict allow-lists that explicitly exclude dangerous integration points such as foreignObject and annotation-xml with HTML encoding attributes. Developers should also audit any custom serialization code to ensure that programmatic insertion of script, style, and comment nodes does not bypass existing sanitization layers. Implementing Content Security Policy headers can provide an additional layer of defense by restricting the sources from which scripts and stylesheets are loaded, thereby mitigating the impact of successful CSS-based attacks. Regular security assessments focusing on DOM manipulation patterns and sanitizer configuration reviews will help maintain a secure posture against evolving injection techniques that exploit parser differentials and namespace ambiguities.