Skip to content

CVE-2026-104736: LearnPress WordPress LMS Plugin Unauthenticated PHP Object Injection via checkout-email Deserialization

Density:
C-Level Executive Briefing CVE-2026-104736 CRITICAL SCORE 92/100

Critical unauthenticated PHP Object Injection flaw (CVSS 9.8) in the LearnPress WordPress LMS plugin through version 4.4.10. During guest checkout (?lp-ajax=checkout), LP_Checkout::process_checkout_handler() reads the checkout-email parameter without email filtering and saves it to the user session via maybe_serialize() prior to nonce verification. Because maybe_serialize() passes already-serialized strings through unchanged, subsequent calls to LP_Session_Handler::get() invoke PHP unserialize() with allowed_classes unrestricted, triggering POP gadget chains for Remote Code Execution.

HTS

HERMES THREAT SCORE & WEB CMS INFRASTRUCTURE EVALUATION

Target: LearnPress WordPress LMS Plugin Checkout & Session Handler (inc/class-lp-checkout.php & inc/class-lp-session-handler.php)
Confidence: 99%
92 / 100
CRITICAL

Measures real-world operational relevance, exploit weaponization, and active threat posture.

Dimension Breakdown
Exploitability 19 / 20
Threat Activity 17 / 20
Weaponization 19 / 20
Exposure 19 / 20
Prevalence 18 / 20
Impact 19 / 20
Exploit Maturity 18 / 20
Attack Chain Potential 19 / 20
โš–๏ธ Divergence & Operational Rationale

CVSS v3.1 scores CVE-2026-104736 at 9.8 (Critical), and the Hermes Threat Score aligns closely at 92 (CRITICAL). LearnPress is deployed across more than 90,000 corporate training portals, universities, and e-learning platforms. Two subtle architectural mistakes make CVE-2026-104736 trivially exploitable without credentials or nonces: (1) LP_Checkout::process_checkout_handler() calls session->set('checkout-email', ...) before validate_checkout_fields() ever verifies the learn-press-checkout-nonce, and (2) WordPress's core maybe_serialize() helper checks is_serialized() and returns already-serialized strings untouchedโ€”delivering the attacker's raw O:... payload directly to LP_Helper::maybe_unserialize() where @unserialize() was invoked without allowed_classes => false.

๐Ÿ•ธ๏ธ Connected Knowledge Graph & Provenance

CVE-2026-104736: LearnPress WordPress LMS Plugin Unauthenticated PHP Object Injection via checkout-email DeserializationVULNERABILITY

Connected Nodes: 1
Active Relationships (Outgoing)
→ affectsPRODUCTMicrosoft Office & 365 Apps
98% VERY_HIGH

Software platform affected by security vulnerabilities and agentic attack patterns.

๐Ÿ” Why is this related? (Evidence & Provenance)

“Confirmed security vulnerability in Microsoft Office & 365 Apps documented in Hermes dossier.”

Supporting Verified Evidence:

On October 16โ€“17, 2026, Patchstack and Wordfence Threat Intelligence disclosed CVE-2026-104736 (remediated in LearnPress 4.4.11 via WordPress Plugin Trac Changeset 3750024), a critical Unauthenticated PHP Object Injection vulnerability (CWE-502: Deserialization of Untrusted Data) affecting the LearnPress โ€“ WordPress LMS Plugin (learnpress) in all versions up to and including 4.4.10 (CVSS v3.1 9.8 Critical).

LearnPress provides an unauthenticated AJAX checkout handler (?lp-ajax=checkout) to support guest course purchases. When handling a POST request in LP_Checkout::process_checkout_handler() (inc/class-lp-checkout.php), the plugin extracts the checkout-email parameter using LP_Request::get_param( 'checkout-email' ) without specifying an 'email' sanitization type and immediately stores the value into the visitorโ€™s session via LearnPress::instance()->session->set( 'checkout-email', $this->_checkout_email )โ€”before verifying the checkout CSRF nonce. Because LP_Session_Handler::set() wraps the value in WordPressโ€™s maybe_serialize(), which leaves strings that already match PHP serialized syntax (is_serialized()) untouched, an attacker can store a raw serialized PHP object string (O:...) in the session and trigger unrestricted @unserialize() execution whenever session->get( 'checkout-email' ) is called.


Root Cause 1: Pre-Nonce Session Persistence Without Email Type Filtering

Section titled โ€œRoot Cause 1: Pre-Nonce Session Persistence Without Email Type Filteringโ€

In inc/class-lp-checkout.php (lines 389โ€“405 in version 4.4.10), LP_Checkout::process_checkout_handler() processes incoming POST requests to the checkout endpoint:

// VULNERABLE: inc/class-lp-checkout.php (LearnPress <= 4.4.10)
public function process_checkout_handler() {
if ( strtolower( $_SERVER['REQUEST_METHOD'] ) != 'post' ) {
return;
}
/**
* Set default fields from request
*/
$this->payment_method_str = LP_Request::get_param( 'payment_method' );
$this->order_comment = LP_Request::get_param( 'order_comments' );
// FLAW 1: Calls get_param() without the 3rd argument ($type = 'email'),
// defaulting to sanitize_text_field() which preserves PHP serialized strings!
$this->_checkout_email = LP_Request::get_param( 'checkout-email' );
if ( $this->_checkout_email ) {
// FLAW 2: Persists attacker input into the session BEFORE process_checkout()
// and BEFORE validate_checkout_fields() checks learn-press-checkout-nonce!
LearnPress::instance()->session->set( 'checkout-email', $this->_checkout_email );
}
// do checkout (where nonce verification actually occurs)
$this->process_checkout();
}

Because LP_Request::get_param( 'checkout-email' ) omits the $type = 'email' parameter, LearnPress applies sanitize_text_field(), which strips HTML tags and line breaks but preserves double quotes ("), colons (:), semicolons (;), and braces ({})โ€”leaving a serialized PHP object payload completely intact.

Root Cause 2: The WordPress maybe_serialize() Pass-Through Trap & Unrestricted unserialize()

Section titled โ€œRoot Cause 2: The WordPress maybe_serialize() Pass-Through Trap & Unrestricted unserialize()โ€

Why doesnโ€™t saving a string into the LearnPress session safely serialize the attackerโ€™s payload as a harmless string (s:42:"O:8:...")? Look at LP_Session_Handler::set() and LP_Session_Handler::get() in inc/class-lp-session-handler.php (lines 373โ€“394):

// VULNERABLE: inc/class-lp-session-handler.php (Lines 373-394)
public function set( string $key, $value, bool $force_change = false ) {
if ( $value !== $this->get( $key ) ) {
// WordPress core maybe_serialize($value) checks:
// if ( is_serialized( $data ) ) { return $data; }
// Because $value is ALREADY a valid serialized string ("O:..."),
// maybe_serialize() returns the raw attacker payload unchanged!
$this->_data[ sanitize_key( $key ) ] = maybe_serialize( $value );
$this->_dirty = true;
if ( $force_change ) {
$this->save_data();
}
}
}
public function get( string $key, $default = '' ) {
$key = sanitize_key( $key );
return isset( $this->_data[ $key ] )
? LP_Helper::maybe_unserialize( $this->_data[ $key ] )
: $default;
}

And inside inc/class-lp-helper.php (lines 25โ€“43 in <= 4.4.10), LP_Helper::maybe_unserialize() invoked native PHP unserialize() without restricting object instantiation:

// VULNERABLE: inc/class-lp-helper.php (LearnPress <= 4.4.10)
public static function maybe_unserialize( $original ) {
if ( is_serialized( $original ) ) {
// FLAW 3 (CWE-502): Invokes @unserialize() without ['allowed_classes' => false]!
return @unserialize( trim( $original ) );
}
return $original;
}

Even within the same HTTP request, after session->set( 'checkout-email', ... ) executes, process_checkout() invokes validate_checkout_fields(), which checks $this->is_enable_guest_checkout() and calls $this->get_checkout_email()โ€”which immediately executes LearnPress::instance()->session->get( 'checkout-email' ) and triggers @unserialize() on the attackerโ€™s payload!

flowchart TD
subgraph Attacker["Unauthenticated Remote Attacker"]
POST["POST /?lp-ajax=checkout<br/>Body: checkout-email=O:21:\"Monolog\\Handler\\...\":1:{...}<br/>(No valid nonce or account required)"]
end
subgraph LearnPress["LearnPress WordPress Plugin (<= 4.4.10)"]
Handler["LP_Checkout::process_checkout_handler()<br/>LP_Request::get_param('checkout-email')<br/>Applies sanitize_text_field() โ€” preserves O:... syntax"]
SessionSet["LP_Session_Handler::set('checkout-email', $val)<br/>Calls WordPress maybe_serialize($val)<br/>is_serialized($val) == true -> Stored UNCHANGED!"]
SessionGet{"LP_Session_Handler::get('checkout-email')<br/>Calls LP_Helper::maybe_unserialize()<br/>@unserialize() without allowed_classes => false (CWE-502)"}
POST --> Handler
Handler -- "Executes BEFORE nonce check!" --> SessionSet
SessionSet --> SessionGet
end
subgraph Impact["WordPress CMS Compromise"]
SessionGet --> POP["Instantiates Arbitrary PHP Gadget Chains<br/>(WooCommerce / Elementor / Monolog / Guzzle / WP Core)"]
POP --> RCE["Unauthenticated Remote Code Execution (RCE),<br/>Arbitrary File Deletion (wp-config.php), or SQLi"]
end
style SessionSet fill:#ff4d4d,stroke:#990000,color:#ffffff
style SessionGet fill:#ff1a1a,stroke:#800000,color:#ffffff

Official Patch Analysis (LearnPress 4.4.11 โ€” Trac Changeset 3750024)

Section titled โ€œOfficial Patch Analysis (LearnPress 4.4.11 โ€” Trac Changeset 3750024)โ€

ThimPress remediated CVE-2026-104736 in version 4.4.11 (WordPress Plugin Trac Changeset 3750024) by applying defense-in-depth at both the input source (inc/class-lp-checkout.php) and the deserialization sink (inc/class-lp-helper.php):

--- a/learnpress/trunk/inc/class-lp-checkout.php
+++ b/learnpress/trunk/inc/class-lp-checkout.php
@@ -396,7 +396,7 @@
$this->payment_method_str = LP_Request::get_param( 'payment_method' );
$this->order_comment = LP_Request::get_param( 'order_comments' );
- $this->_checkout_email = LP_Request::get_param( 'checkout-email' );
+ $this->_checkout_email = LP_Request::get_param( 'checkout-email', '', 'email' );
if ( $this->_checkout_email ) {
LearnPress::instance()->session->set( 'checkout-email', $this->_checkout_email );
}
--- a/learnpress/trunk/inc/class-lp-helper.php
+++ b/learnpress/trunk/inc/class-lp-helper.php
@@ -22,22 +22,22 @@
- public static function maybe_unserialize( $original ) {
+ public static function maybe_unserialize( $original, bool $allow_classes = false ) {
if ( is_serialized( $original ) ) {
$ fixed = preg_replace_callback(
'!s:(\d+):"(.*?)";!',
function ( $math ) {
return 's:' . strlen( $math[2] ) . ':"' . $math[2] . '";';
},
$original
);
- $result = @unserialize( trim( $fixed ) );
+ $result = @unserialize( trim( $fixed ), array( 'allowed_classes' => $allow_classes ) );
if ( ! $result ) {
- $result = @unserialize( trim( $original ) );
+ $result = @unserialize( trim( $original ), array( 'allowed_classes' => $allow_classes ) );
}
return $result;
}
return $original;
}
  1. Source Sanitization: Passing 'email' as the third argument to LP_Request::get_param() invokes WordPressโ€™s sanitize_email(), which strips double quotes ("), colons (:), semicolons (;), and braces ({}), rendering any PHP serialized string syntactically invalid.
  2. Sink Hardening: LP_Helper::maybe_unserialize() now defaults to $allow_classes = false and passes array( 'allowed_classes' => false ) to @unserialize(), converting any serialized object into an inert __PHP_Incomplete_Class instance without invoking magic methods (__wakeup(), __destruct(), __toString()).

Administrators managing WordPress sites with LearnPress installed should inspect web server access logs for POST requests to ?lp-ajax=checkout or /lp-checkout/ and audit the wp_learnpress_sessions database table for serialized object strings (O: or C:). Consult our guides on Initial Access TTPs and Linux Process Memory Analysis for web server post-exploitation triage.

title: LearnPress WordPress Plugin Unauthenticated PHP Object Injection via checkout-email (CVE-2026-104736)
id: 6c4d9e81-1047-436a-9f12-learnpress36
status: experimental
description: Detects unauthenticated HTTP POST requests to LearnPress checkout endpoints containing PHP serialized object strings in the checkout-email parameter exploiting CVE-2026-104736.
references:
- https://plugins.trac.wordpress.org/changeset/3750024/learnpress
- https://nvd.nist.gov/vuln/detail/CVE-2026-104736
author: Hermes Threat Intelligence
date: 2026/10/18
logsource:
category: webserver
detection:
selection_request:
cs-method: 'POST'
cs-uri-query|contains:
- 'lp-ajax=checkout'
- 'lp-checkout'
selection_payload:
request_body|contains:
- 'checkout-email=O%3A'
- 'checkout-email=O:'
- 'checkout-email=C%3A'
- 'checkout-email=C:'
- 'checkout-email=a%3A'
- 'checkout-email=a:'
condition: selection_request or selection_payload
falsepositives:
- Legitimate guest checkout POST requests where checkout-email is a standard RFC 5322 email address
level: critical
tags:
- attack.initial_access
- attack.execution
- attack.t1190
- cve.2026-104736

  1. Update LearnPress to Version 4.4.11 or Later Immediately: Upgrade the learnpress plugin to version 4.4.11 (or later) via the WordPress Admin Dashboard or WP-CLI (wp plugin update learnpress).
  2. Purge Active LearnPress Sessions (wp_learnpress_sessions): Because serialized payloads injected prior to patching may remain persisted inside the wp_learnpress_sessions database table until session expiration, truncate or purge untrusted guest rows from wp_learnpress_sessions immediately after upgrading:
    DELETE FROM wp_learnpress_sessions WHERE session_value LIKE '%checkout-email%';
  3. Deploy WAF Virtual Patching on checkout-email: Enforce the ModSecurity / Cloudflare WAF rule above to block any HTTP POST request where checkout-email contains PHP serialization prefixes (O:<digits>:, C:<digits>:, or a:<digits>:).
  4. Disable Unauthenticated Guest Checkout If Unused: In LearnPress > Settings > Payments > Guest Checkout, disable guest checkout if your learning portal requires users to register and authenticate prior to enrolling in courses.