CVE-2026-92212 vulnerability and BitFire protection

How BitFire Blocks CVE-2026-92212: JetFormBuilder Reflected XSS

WordPress vulnerability research

BitFire's FREE WAF blocks the malicious query-string payloads behind the JetFormBuilder CVE-2026-92212 reflected XSS before WordPress processes the request.

Unauthenticated Medium Severity (CVSS 6.1) Script Execution in Victim Session Reflected Cross-Site Scripting
BitFire · Vulnerability advisoryResearch published
AdvisoryCVE-2026-92212
ComponentJetFormBuilder — Dynamic Blocks Form Builder
Relevant sourceassets/build/frontend/main.js — CalculatedFormula formula engine; sink in assets/build/frontend/advanced.reporting.js (innerHTML error-message renderer)
Executive summary

What WordPress administrators need to know

JetFormBuilder — Dynamic Blocks Form Builder versions before 3.6.5.4 carry a reflected cross-site scripting flaw that lets an unauthenticated attacker run web script in a visitor's browser. A crafted GET link sets the URL query variable a form's preset field consumes; the value survives server-side attribute encoding, the client-side Calculated Field formula engine interpolates it into a validation message with no HTML-entity encoding, and the reporting renderer writes that message through innerHTML. The result is attacker script executing in the page's origin with the victim's session (CVSS 6.1). BitFire's FREE WAF inspects the query string, detects the matching script payload, and blocks the request before WordPress or JetFormBuilder processes it.

At a glance

Key facts

  • Unauthenticated reflected XSS, CVSS 6.1 (AV:N/AC:L/PR:N/UI:R/S:C), affecting JetFormBuilder releases below 3.6.5.4.
  • Exploitation requires only a victim opening a crafted GET link to a page whose form pairs a query-variable preset with a Calculated Field or validation formula.
  • The 3.6.5.3 formula engine interpolates field values into messages with zero HTML-entity encoding, and advanced.reporting.js renders those messages through innerHTML.
  • The generic query_var preset source returns raw $_GET values; only the hidden-field variant strips tags server-side, a partial mitigation for that block type alone.
  • Fixed entirely client-side in 3.6.5.4: main.js gains an HTML-entity escaper at the formula-output stage — no PHP changes.
  • BitFire FREE's WAF inspects query strings and blocks matching script payloads before WordPress processes the request, with no CVE-specific virtual patch required.
01
Vulnerability overview

Understand the exposure

The affected component, attack path, and practical risk for WordPress websites.

Affected componentJetFormBuilder — Dynamic Blocks Form Builder
Potential reach80000 installations
Attack techniquereflected cross-site scripting
Published2026-09-26
BitFire's FREE WAF meets this attack where it starts — the malicious script payload in the query string is detected and the request is blocked before WordPress loads a single plugin file.
02
Technical analysis

How the vulnerability works

Research details, affected versions, exploitation behavior, and remediation guidance.

How CVE-2026-92212 Works

CVE-2026-92212 is an unauthenticated, reflected cross-site scripting flaw in JetFormBuilder's frontend. The attack needs one thing: a victim who opens an attacker-crafted GET link to a page hosting a form that pairs a URL Query Variable preset field with a Calculated Field or validation formula — both standard plugin features. The generic query_var source returns the raw $_GET value and renders it into the field's value attribute with attribute-context escaping only; the browser intentionally decodes those entities back into the field's client-side value. The vulnerable formula engine then interpolates that value into message strings with no HTML-entity encoding, and the unchanged validation renderer in advanced.reporting.js writes the message through innerHTML. Attacker-injected script executes in the page's origin with the victim's session.

BitFire FREE WAF: The Payload Dies Before WordPress Runs

BitFire's FREE WAF inspects URLs and query strings before WordPress or any plugin processes a request — exactly where this attack lives. The entire exploit is the link itself: the malicious script payload rides in the query string that the preset field consumes. When inspected request data contains matching cross-site scripting content, the WAF fires and the request is blocked before the query_var source ever reads $_GET, before the form renders, and before the vulnerable formula engine executes in any browser. No message is built and no innerHTML sink is reached. The detection requires a matching script payload in the inspected request data — precisely what this attack delivers — and because the rule is behavior-based, it stops this flaw without a CVE-specific virtual patch.

Update to JetFormBuilder 3.6.5.4 Immediately

JetFormBuilder 3.6.5.4 closes the hole at the formula-output stage: the frontend bundle gains an HTML-entity escaper that encodes Calculated Field output before any consumer writes it into the DOM, making query-variable values inert in HTML contexts. The fix is entirely client-side — no PHP changed — and the changelog names it plainly: 'FIX: Prevent XSS in Calculated Field formulas.' Every release below 3.6.5.4 is affected. Update now, and verify the deployed plugin reports version 3.6.5.4 or higher before treating the site as patched.

If Your Site Was Affected, Investigate for Persistence

Patching closes the known injection path; it does not undo a compromise that already happened. If your site ran a version below 3.6.5.4, treat every opened link as a potential injection vector and investigate — an injected script runs with the victim's session and leaves no obvious file behind. Run BitFire Threat Hunter to sweep for backdoor WordPress administrator accounts, hidden database triggers, long-running PHP processes, and droppers that can restore malware or reinfect the site. Remove every persistence mechanism it finds and rotate administrator credentials. A clean-looking file tree is not proof of a clean site.

Conclusion: Close the Window with BitFire

An unauthenticated flaw that needs nothing more than a clicked link is exactly what BitFire is built to stop. BitFire FREE's WAF inspects query strings and blocks matching script payloads before WordPress runs — no virtual patch, no waiting on a vendor signature. Update JetFormBuilder to 3.6.5.4, put BitFire in front of every request, and run Threat Hunter on any site that carried the vulnerable version. Secure your site with BitFire today.

03
Source review

Vulnerable and fixed code

The relevant source is located in assets/build/frontend/main.js — CalculatedFormula formula engine; sink in assets/build/frontend/advanced.reporting.js (innerHTML error-message renderer).

BeforeVulnerable behavior
// Vulnerable behavior, abridged from the supplied writeup.
// JetFormBuilder 3.6.5.3, assets/build/frontend/main.js (minified bundle):
// formula output reaches message consumers with no HTML-entity encoding;
// escaper artifacts ('<', '>', '"', '&' and the [&<>"''] character class)
// are absent from the 3.6.5.3 bundle.
this.formula.setResult = () => { this.message = this.formula.calculateString(); } // raw, unencoded output
// Unchanged consumer, assets/build/frontend/advanced.reporting.js:
s.classList.add("error-message"); s.innerHTML = e; // message written as HTML
AfterCorrected behavior
// Corrected behavior, abridged from the supplied writeup.
// JetFormBuilder 3.6.5.4 adds an HTML-entity escaper in the CalculatedFormula
// region of assets/build/frontend/main.js: a character class covering &, <, >,
// " and ' plus mappings '<' -> '<', '>' -> '>', '"' -> '"', '&' -> '&',
// applied to formula-derived strings before any DOM consumer writes them
// (exact minified call sites were not excerptable from the bundle).
this.formula.setResult = () => { this.message = htmlEntityEncode(this.formula.calculateString()); } // entity-encoded before any innerHTML consumer
04
Zero-day protection

Protection from the first exploit request

BitFire protects WordPress servers on day zero—before a vulnerability is publicly known and before other vendors have time to develop signatures or patches.

01 · VerifyStop unknown clients

Bot controls and browser verification stop untrusted automated clients before previously unknown exploit code reaches WordPress.

02 · DetectBlock malicious behavior

General WAF protections identify dangerous request behavior and hostile payloads without waiting for a vulnerability-specific signature.

03 · PreventContain attacks at runtime

RASP follows execution inside PHP and prevents unauthorized changes to protected files, accounts, and database content.

BitFire · WordPress protectionZero-day ready
BitFire zero-day WordPress vulnerability protection
BitFire combines verified-client controls, behavior-based WAF detection, and runtime RASP enforcement to protect WordPress before an exploit has a name, CVE, signature, or vendor patch.
About the author

Cory Marsh

Cory has more than 20 years of internet security experience and is a lead developer on the BitFire project.

Read BitFire security research →
Protect your WordPress website

Add protection before the next exploit arrives.

BitFire combines bot controls, request inspection, malware detection, and runtime protection in one WordPress security platform.

Protect my site free →