/

CVE-2026-28445

Severity:

HIGH RISK

(8.7)

XSS in Typebot RatingButton Embed Component

CVE-2026-28445

Deferred

Vulnerability type

Category:

Cross-Site Scripting (XSS)

CWE:

CWE-79

Impact:

Stored Cross-Site Scripting leading to session hijacking and privilege escalation

Severity:

HIGH RISK

(8.7)

CVSS version:

3.1

Catch this CVE while code is being written

Detect vulnerable code directly in pull requests, so CVEs are fixed before merge.

Summary

A stored cross-site scripting (XSS) flaw in Typebot's embed package allows attacker-controlled SVG content to be rendered via Solid's innerHTML without sanitization.

When a malicious typebot is imported or crafted by a collaborator, arbitrary HTML and JavaScript can run in the authenticated builder context, enabling session hijacking and privilege escalation within the builder application.

Affected context

The vulnerability affects Typebot instances using versions 3.15.2 and earlier where:

  • The RatingButton component from the embed package is available and rendered in the builder preview.
  • The customIcon.svg field can be influenced by imported bots or collaborators.
  • Builder previews are rendered inline on builder.typebot.io under a Content Security Policy that allows unsafe-inline.

In this context, rating blocks are not treated as unsafe content, so their icon HTML is not sanitized or isolated in a sandbox, leaving the builder UI exposed to attacker-supplied markup.

Exploit preconditions

  • Attack surface: Typebot builder interface and preview rendering of bots containing RatingButton components.
  • Required access: Ability to introduce or modify a bot definition that will be opened in the builder (e.g., via import, shared template, or collaborator access).
  • Trigger point: A builder user opens or previews a malicious bot containing a RatingButton whose customIcon.svg field includes crafted HTML/JavaScript.
  • Why exploitation is possible: The RatingButton component injects the customIcon.svg value directly into the DOM using Solid's innerHTML, with no sanitization, while the relevant rating blocks are not flagged as isUnsafe. The builder renders on its own origin under a CSP that permits inline script execution, and this path bypasses the Web Worker sandbox used for Script blocks.

Why this happens

The issue originates from an unsafe DOM injection pattern where user-controlled markup is written directly into the page via innerHTML without sanitization.

Although DOMPurify is present and actively used elsewhere (such as in StreamingBubble.tsx), the RatingButton component's customIcon.svg field is treated as trusted and not fed through the sanitizer.

This maps to CWE-79: Improper Neutralization of Input During Web Page Generation, where attacker-controlled data is interpreted as active content in a browser context.

The additional design assumption that rating blocks are not "unsafe" allowed this HTML injection path to bypass existing sandboxing and content isolation mechanisms.

Potential impact

  • Theft of builder session cookies or tokens, leading to account takeover within the builder.
  • Execution of arbitrary JavaScript in the context of builder.typebot.io.
  • Privilege escalation by performing actions as the compromised builder user (e.g., modifying bots, accessing sensitive configuration data).
  • Persistent compromise of project resources through backdoored or altered typebots.
  • Pivoting to other integrated systems if the builder account has connected services or secrets.

General mitigation guidance

Effective mitigation centers on consistently treating all user-supplied markup as untrusted and minimizing direct DOM injection:

  • Route all HTML- or SVG-like content through a well-configured HTML sanitizer (such as DOMPurify) before rendering, ensuring dangerous tags, attributes, and event handlers are stripped.
  • Avoid using innerHTML or equivalent raw HTML bindings for user-provided content; prefer declarative templates or safe component APIs where possible.
  • Classify components like rating blocks as potentially unsafe when they can carry attacker-influenced HTML, and subject them to the same isolation and sanitization rules as scriptable blocks.
  • Tighten CSP policies to reduce reliance on unsafe-inline where feasible, favoring nonces or hashes for permitted scripts.
  • Limit the privileges of builder sessions and ensure sensitive actions require additional verification or scoped tokens, reducing the blast radius if XSS occurs.

How teams detect issues like this

Organizations can identify and monitor for this class of issue by:

  • Applying static analysis or linters that flag direct innerHTML, dangerouslySetInnerHTML, or similar raw HTML bindings, especially when fed by user or imported data.
  • Adding code review checklists that require explicit justification and sanitization for any feature rendering dynamic HTML or SVG.
  • Enforcing architectural policies that route all rich-text or markup-bearing fields through a shared sanitization utility, and validating this in automated tests.
  • Implementing security-focused integration tests that attempt to inject basic XSS payloads through customizable UI elements and verify they are neutralized.
  • Using web application firewalls and browser security reports (e.g., CSP violation reports) to detect suspicious inline script execution patterns in production.

Sources

SourceLink
github.comgithub.com/baptisteArno/typebot.io/commit/474ecbf46bc47a75265bada2599f12b2179de375
github.comgithub.com/baptisteArno/typebot.io/releases/tag/v3.16.0
github.comgithub.com/baptisteArno/typebot.io/security/advisories/GHSA-6m7c-xfhp-p9fh

Frequently asked

questions

Yes, as long as an attacker can cause a builder user to open or preview a malicious typebot (for example, by sharing an importable bot or collaborating on a workspace), the XSS executes in the victim's browser against the builder origin.

The malicious bot must be loaded in an authenticated builder session to have meaningful impact. The attacker typically needs a way to supply or modify bot content that a logged-in builder user will open, but does not necessarily need the victim's credentials.

The most robust pattern is to eliminate unsanitized raw HTML injection: route all user-controlled markup fields (including SVG) through a centralized sanitizer, avoid direct innerHTML usage, and treat such content as untrusted by default, subject to the same sandbox and isolation rules as scriptable components.

Establish a secure rendering policy where dynamic content must use vetted components and shared sanitization utilities, backed by static analysis rules and code review gates that block new instances of unsanitized HTML injection. Combine this with stronger CSP configurations and test suites that explicitly check for XSS regressions.

Find out what's already
exploitable in your codebase.