CVE-2026-10795 vulnerability and BitFire protection

How BitFire Stops CVE-2026-10795 UpdraftPlus Authentication Bypass

WordPress vulnerability research

BitFire blocks automated forged UpdraftPlus RPC requests and uses PRO RASP to prevent a malicious plugin ZIP from creating unauthorized PHP files.

Unauthenticated High Severity Remote Code Execution Risk Authentication Bypass
BitFire · Vulnerability advisoryResearch published
AdvisoryCVE-2026-10795
ComponentUpdraftPlus: WP Backup & Migration Plugin
Relevant sourcevendor/team-updraft/common-libs/src/updraft-rpc/class-udrpc2.php: UpdraftPlus_Remote_Communications_V2::wp_loaded() and decrypt_message()
Executive summary

What WordPress administrators need to know

CVE-2026-10795 is a high-severity authentication bypass in UpdraftPlus: WP Backup & Migration Plugin through free version 1.26.4. Sites are exposed when they have an active UpdraftCentral key, or an active Migrator key in a paid installation. An unauthenticated attacker can submit a forged remote communications POST request to `UpdraftPlus_Remote_Communications_V2::wp_loaded()`, select the unsigned legacy message format, exploit an unchecked decryption failure, and dispatch RPC commands with the capabilities of the WordPress user connected to that key. If the connected user is an administrator, those commands can upload and activate a malicious plugin ZIP, leading to remote code execution. BitFire rejects unknown automated RPC clients at the request layer, while BitFire PRO RASP independently prevents the unauthorized PHP file creation required to install the attacker's plugin code.

At a glance

Key facts

  • UpdraftPlus free versions up to and including 1.26.4 are affected
  • Exposure requires an active UpdraftCentral key or, on paid installations, an active Migrator key
  • No WordPress login is required to submit a forged RPC request
  • Legacy format 1 bypasses the signature verification required for format 2
  • A forged command can upload and activate a malicious plugin as the connected administrator
  • BitFire blocks unknown exploit automation and PRO RASP prevents unauthorized PHP file creation
01
Vulnerability overview

Understand the exposure

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

Affected componentUpdraftPlus: WP Backup & Migration Plugin
Potential reach3,000,000+ installations
Attack techniqueauthentication bypass
Published2026-06-10
BitFire rejects unknown automated RPC clients before UpdraftPlus dispatches their commands and uses PRO RASP to stop the unauthorized PHP files inside a malicious plugin ZIP.
02
Technical analysis

How the vulnerability works

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

CVE-2026-10795 Turns a Trusted Remote Connection Into an Attack Path

UpdraftPlus supports remote backup, migration, and site-management operations through its UDRPC communications layer. CVE-2026-10795 affects free releases through 1.26.4 and applies only when the site has an active UpdraftCentral key or, for paid installations, an active Migrator key. The listener is reachable without a WordPress session. An attacker who satisfies the vulnerable protocol conditions can forge a message for an existing connection and make the listener process it as the WordPress user stored with that key. This is an authentication failure rather than a missing nonce: the cryptographic message checks are supposed to establish that a trusted remote system sent the command, but the vulnerable path permits an outsider to bypass them. The resulting administrator-level command execution accounts for the 8.1 CVSS score and high severity rating.

The Legacy Message Format Skips Signature Verification

The attack begins with a POST request containing `format`, `key_name`, and `udrpc_message`. `wp_loaded()` accepts protocol formats 1 and 2, but vulnerable code checks the message signature only when `format >= 2`. Selecting legacy format 1 therefore removes the signature gate before decryption. The request must still correspond to an active remote connection and produce a message that passes the listener's key-name, time-window, and command checks, which is why the published CVSS vector rates attack complexity as high. Those later structural checks do not restore authentication: once format 1 has skipped signature verification, they validate the shape and freshness of attacker-controlled content rather than proving who sent it.

A Failed RSA Decryption Becomes a Predictable Encryption Key

The second defect is in `decrypt_message()`. UpdraftPlus extracts an encrypted symmetric key from the submitted message and asks phpseclib to decrypt it with the site's private key. An invalid value can make that RSA operation return `false`. Version 1.26.4 does not test the return value before calling `setKey()`, so the failure is coerced into predictable all-zero key material for the symmetric decryption step. An attacker can construct ciphertext for that predictable state and recover a JSON command that the listener accepts. The 1.26.5 correction rejects `false`, non-string, and undersized symmetric keys, rejects a decrypted message unless it is a string, and limits legacy format 1 to narrowly defined migration commands and key names.

A Trojan Plugin ZIP Can Execute as the Connected Administrator

After decoding the forged message, the UpdraftCentral listener retrieves the `user_id` associated with the remote key and calls `wp_set_current_user()` before dispatching the requested command. A key connected by an administrator therefore gives plugin-management commands the administrator's `install_plugins` and `activate_plugins` capabilities. The attacker can use that context to send a plugin upload, have WordPress unpack the ZIP beneath the plugins directory, and activate its entry point. The archive itself is only a delivery container; remote code execution occurs when attacker-controlled PHP from the installed plugin is loaded or activated. That code may then access WordPress core behavior, the database, and the filesystem with the privileges available to the site process.

BitFire Stops the Forged Request and the PHP File Outcome

Automated exploitation requires an unknown client or impersonated browser to send attacker-controlled RPC POST values, including `format`, `key_name`, and `udrpc_message`. BitFire bot protection detects unknown automation and browser impersonation when those clients submit unknown GET or POST parameters, allowing it to reject the request before WordPress loads `wp_loaded()` and dispatches the forged command. If a request reaches the vulnerable listener through another vector, BitFire PRO RASP supplies an independent runtime boundary. Its filesystem policy prevents unauthorized PHP file creation or modification from any request path. Unpacking a Trojan plugin ZIP must create attacker-controlled PHP inside the plugins directory, so RASP blocks the operation required to turn the authentication bypass into persistent plugin code. This is outcome protection, not a claim that the WAF treats every authorization flaw as a malicious payload.

Conclusion: Protect Privileged Plugin Installation Beyond the RPC Protocol

UpdraftPlus disclosed the issue on June 10, 2026, and its changelog identifies free version 1.26.5 as the security correction; paid administrators should use the corresponding corrected release supplied for their edition. Administrators can also inventory active UpdraftCentral and Migrator connections, remove keys that are no longer required, review requests containing `udrpc_message`, and inspect the plugins directory for unexpected additions. CVE-2026-10795 demonstrates why site administrators need a security solution with built-in access controls and zero-day protection when a plugin's cryptographic authentication fails. BitFire's behavior-based bot controls can stop unknown automated RPC clients before vulnerable code runs, while PRO RASP prevents the unauthorized PHP creation needed to install the Trojan plugin even before a vulnerability-specific signature exists.

03
Source review

Vulnerable and fixed code

The relevant source is located in vendor/team-updraft/common-libs/src/updraft-rpc/class-udrpc2.php: UpdraftPlus_Remote_Communications_V2::wp_loaded() and decrypt_message().

BeforeVulnerable behavior
// Vulnerable request flow, abridged.
$format = $_POST['format'];

// Format 1 skips signature verification.
if ( $format >= 2 ) {
    verify_signature( $_POST['udrpc_message'], $_POST['signature'] );
}

$sym_key = $rsa->decrypt( base64_decode( $sym_key ) );

// A failed RSA decryption is passed to the symmetric cipher.
$rij->setKey( $sym_key );
$message = $rij->decrypt( $ciphertext );

dispatch_rpc_command( json_decode( $message, true ) );
AfterCorrected behavior
// Required corrected behavior, abridged.
$sym_key = $rsa->decrypt( base64_decode( $sym_key ) );

if ( false === $sym_key || ! is_string( $sym_key ) || strlen( $sym_key ) < 16 ) {
    return false;
}

$message = decrypt_message( $_POST['udrpc_message'] );
if ( ! is_string( $message ) ) {
    return; // Reject undecryptable messages.
}

// Legacy format 1 may perform only narrowly scoped migration commands.
if ( $format < 2 && ! legacy_migration_command_is_allowed( $command, $key_name ) ) {
    return;
}
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 →