CVE-2026-78159 vulnerability and BitFire protection

How BitFire Blocks Automated CVE-2026-78159 Attacks

WordPress vulnerability research

BitFire blocks automated Events Calendar exploit delivery, while PRO RASP prevents unauthorized PHP files and administrator persistence.

Unauthenticated Critical Severity Remote Code Execution Callable Injection
BitFire · Vulnerability advisoryResearch published
AdvisoryCVE-2026-78159
ComponentThe Events Calendar
Relevant sourcesrc/Tribe/Views/V2/Widgets/Service_Provider.php: is_safe_widget_instance(); common/src/Tribe/Utils/Element_Classes.php: parse() and parse_array()
Executive summary

What WordPress administrators need to know

CVE-2026-78159 is a critical unauthenticated remote code execution vulnerability in The Events Calendar through version 6.17.3. Exploitation requires comments to be enabled on `tribe_events` posts and a submitted comment containing a crafted `wp:legacy-widget` block. A serialized plain array bypasses object-focused validation, receives a valid integrity hash, and places attacker-controlled callable values in the widget's `classes` map. Rendering the event invokes those values as PHP callables. BitFire FREE Bot Protection blocks automated comment submission before vulnerable code runs. BitFire PRO RASP independently denies unauthorized PHP-file writes and administrator creation attempted after code execution.

At a glance

Key facts

  • Versions through 6.17.3 are affected; version 6.17.3.1 contains the fix
  • Reachability requires comments enabled on `tribe_events` posts and a crafted legacy-widget comment
  • A plain serialized array bypasses validation and receives a recomputed integrity hash
  • The attacker-controlled `classes` map reaches an arbitrary-callable invocation sink
  • BitFire FREE blocks automated comment delivery before WordPress processes the payload
  • BitFire PRO RASP blocks unauthorized PHP writes and administrator creation at runtime
01
Vulnerability overview

Understand the exposure

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

Affected componentThe Events Calendar
Potential reach600,000 installations
Attack techniquecallable injection
Published2026-09-21
BitFire blocks automated delivery before the vulnerable widget chain runs and uses PRO RASP to stop code execution from becoming persistent PHP or administrator access.
02
Technical analysis

How the vulnerability works

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

How a Comment Reaches the Callable-Injection Sink

The attack begins when an unauthenticated visitor seeds an event with a crafted legacy-widget comment. During single-event rendering, `do_blocks()` processes the comment area and the plugin decodes the block's serialized widget instance. The validator rejects objects but accepts a plain array—and even accepts a failed `unserialize()` result—then recomputes `wp_hash()` over the attacker-controlled data. WordPress consequently accepts the copied widget. Its setup path merges the supplied `classes` map into widget arguments. `Element_Classes::parse_array()` treats each callable value as executable and invokes it, giving the attacker code execution in the WordPress PHP process. Without the required event-comment configuration and planted block, this chain is not reachable.

BitFire FREE Blocks Automated Comment Delivery

BitFire FREE Bot Protection acts at the first boundary: the attempt to submit the crafted comment. Known scanners and attack tools are blocked, while unknown or restricted bots cannot submit forms or POST data. Clients presenting as browsers must pass lightweight JavaScript verification before performing that restricted action, stopping scripts and fake browsers before WordPress stores the malicious block. A trusted bot may be narrowly allowlisted, and a real or successfully verified browser is not claimed to be blocked. For eligible non-commercial sites, this request-layer protection requires no PRO subscription; commercial sites require the appropriate license. This exploit uses a serialized plain array rather than a malicious serialized PHP object, so the protection does not rely on BitFire's WAF object-deserialization rule.

BitFire PRO RASP Denies Persistent Compromise

If the crafted block reaches PHP and its callable executes, BitFire PRO RASP enforces authorization at the dangerous operation. Filesystem protection blocks an unauthenticated request from creating or modifying PHP, preventing the code path from planting a web shell, backdoor, or plugin payload. Database protection rejects unauthorized WordPress user creation and administrator-role assignment, stopping the documented administrator-persistence outcome. These controls do not sanitize the widget instance or claim to suppress every callable; they deny the privileged changes that convert transient execution into durable control. Because RASP evaluates the runtime operation rather than the CVE identifier, the protection does not depend on a vulnerability-specific virtual patch.

If Your Site Was Affected, Investigate for Persistence.

Upgrade immediately to The Events Calendar 6.17.3.1 or later. The patch requires copied instances to decode to arrays and removes the sink by invoking only actual `Closure` objects; serialized function names and array callables become inert data. As an interim measure, disable comments on `tribe_events` posts. Patching closes the known path but does not remove an earlier compromise. Run BitFire Threat Hunter to uncover backdoor WordPress administrator accounts, hidden database triggers, long-running PHP processes, and droppers that restore malware or reinfect the site. Remove every persistence mechanism, preserve and review relevant logs, and rotate affected credentials. An absence of obvious malicious files is not proof that the site is clean.

Deploy Layered BitFire Protection Now

CVE-2026-78159 turns one crafted event comment into critical server-side execution. Deploy BitFire FREE to block automated exploit delivery before WordPress runs, and add BitFire PRO RASP to prevent unauthorized PHP files and administrator persistence at runtime. Then update the plugin and use Threat Hunter to investigate every site that ran an affected release. BitFire provides decisive protection before exploitation, at the privileged operation, and during post-compromise response—without treating security controls as a substitute for patching.

03
Source review

Vulnerable and fixed code

The relevant source is located in src/Tribe/Views/V2/Widgets/Service_Provider.php: is_safe_widget_instance(); common/src/Tribe/Utils/Element_Classes.php: parse() and parse_array().

BeforeVulnerable behavior
protected function is_safe_widget_instance( $serialized ) {
    $data = is_string( $serialized )
        ? @unserialize( $serialized, [ 'allowed_classes' => false ] )
        : false;
    return ! $this->contains_object( $data );
}

// Later, in Element_Classes::parse_array():
if ( is_string( $key ) ) {
    if ( $value instanceof \Closure || is_callable( $value ) ) {
        $value = $value( $this->results );
    }
    $this->parse_string( $key, tribe_is_truthy( $value ) );
}
AfterCorrected behavior
protected function is_safe_widget_instance( $serialized ) {
    if ( ! is_string( $serialized ) ) {
        return false;
    }
    $data = @unserialize( $serialized, [ 'allowed_classes' => false ] );
    return is_array( $data ) && ! $this->contains_object( $data );
}

// Element_Classes::parse_array() now invokes Closure objects only.
if ( is_string( $key ) ) {
    if ( $value instanceof Closure ) {
        $value = $value( $this->results );
    } elseif ( is_callable( $value ) ) {
        _doing_it_wrong( __METHOD__, 'Only Closure instances are invoked; this callable value will be treated as data instead of being called.', '6.12.2.1' );
    }
    $this->parse_string( $key, tribe_is_truthy( $value ) );
}
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 →