The NVD has published CVE-2026-124990, a CVSS 9.8 (Critical) vulnerability in the Masteriyo LMS – LMS Course Builder, Quizzes & Certificates plugin for WordPress, affecting all versions up to and including 3.5.1. The flaw is a classic but devastating PHP Object Injection via insecure deserialization in the plugin's course importer — and it is exploitable remotely over the network without authentication on sites that meet a specific (and common) configuration precondition.
WordPress powers roughly 40% of the web, and LMS plugins like Masteriyo are routinely deployed on marketing sites, corporate training portals, universities, and membership businesses — often by non-technical teams with no patching cadence. An unauthenticated deserialization bug in this stack is not an academic exercise: PHP Object Injection is the reliable foothold primitive that attackers chain into remote code execution, webshell deployment, and full site compromise. If you operate WordPress sites — your own or your clients' — this needs to be in this week's patch window, not next quarter's.
Technical Analysis
Affected Component and Versions
| Attribute | Detail |
|---|---|
| CVE | CVE-2026-124990 |
| CVSS v3.1 | 9.8 (Critical) — vector: NETWORK, unauthenticated |
| Product | Masteriyo LMS – LMS Course Builder, Quizzes & Certificates (WordPress plugin) |
| Affected versions | ≤ 3.5.1 |
| Root cause | CWE-502: Deserialization of Untrusted Data |
How the Vulnerability Works
The vulnerable code path lives in the plugin's course import functionality. When an administrator (or, under the vulnerable configuration, an unauthenticated visitor) uploads a JSON course import file, the plugin parses postmeta string values from that file and passes them through set_post_metas(), which calls PHP's maybe_unserialize() on the attacker-controlled values.
maybe_unserialize() will happily instantiate any serialized PHP object string it is handed — e.g. O:8:"SomeClass":.... If an attacker can identify a usable POP (Property-Oriented Programming) gadget chain in Masteriyo itself, WordPress core, another installed plugin, or the active theme, they can trigger magic methods (__destruct(), __wakeup(), __toString()) during object instantiation and achieve arbitrary file writes, file deletion, or full remote code execution. Even without a perfect gadget, object injection frequently enables arbitrary file deletion (e.g., deleting wp-config.php to force a reinstall-and-takeover flow) — a technique that has been weaponized against WordPress repeatedly.
Exploitation Preconditions
This is the critical nuance defenders must understand. Per the NVD description, unauthenticated exploitation requires all three of the following on the target site:
enable_instructor_registration = trueenable_guest_checkout = true- At least one additional published course/content condition (truncated in the advisory, but consistent with the importer being reachable through a front-end workflow)
These settings are commonly enabled on LMS sites that want frictionless student sign-up and course sales — exactly the public-facing, revenue-generating deployments attackers target. Do not assume you are safe because you "don't use the importer." If those two flags are enabled, the attack surface exists.
Attack Chain (Defender's View)
- Attacker enumerates WordPress sites with Masteriyo LMS active (plugin paths under
/wp-content/plugins/masteriyo/are trivially fingerprintable). - Attacker verifies the vulnerable configuration (public registration/checkout endpoints).
- Attacker submits a crafted course import request containing a JSON payload with a serialized PHP object string in a postmeta value.
set_post_metas()→maybe_unserialize()instantiates the object; the POP gadget chain fires.- Post-exploitation: file write (
/wp-content/uploads/webshell),wp-config.phpmanipulation, rogue admin user creation, or pivot to the underlying host.
Exploitation Status
At the time of publication, CVE-2026-124990 is newly disclosed via NVD. No CISA KEV listing has been confirmed yet, but history with unauthenticated WordPress plugin object-injection flaws is unambiguous: mass scanning and exploit weaponization typically begin within days of disclosure, often before most sites patch. Treat this as actively targeted. Verify your KEV feed daily and prioritize accordingly.
Detection & Response
Sigma Rules
The most reliable observables for this threat are in the web server access logs and PHP application layer: unauthenticated POST requests hitting Masteriyo's import endpoints, serialized object signatures in request bodies, and post-exploitation file writes in upload directories. If your WordPress servers forward nginx/apache logs to your SIEM (they should), these rules will catch both the attempt and the aftermath.
---
title: WordPress Masteriyo LMS Course Import Request - Potential CVE-2026-124990 Probing
id: 3f8a1b2e-9c4d-4e7a-b5f1-2d6c8a0e1f34
status: experimental
description: Detects HTTP requests to Masteriyo LMS course import functionality, which is the attack vector for CVE-2026-124990 unauthenticated PHP Object Injection. Unauthenticated hits against these endpoints should be treated as hostile until patched.
references:
- https://nvd.nist.gov/vuln/detail/CVE-2026-124990
author: Security Arsenal
date: 2026/01/15
tags:
- attack.initial_access
- attack.t1190
logsource:
category: webserver
product: linux
detection:
selection:
cs-method: 'POST'
cs-uri-query|contains:
- 'masteriyo'
cs-uri|contains:
- 'admin-ajax.php'
- 'wp-json/masteriyo'
filter_authenticated:
sc-status:
- 301
- 302
condition: selection and not filter_authenticated
falsepositives:
- Legitimate course imports by site administrators (verify source IP against known admin ranges)
level: high
---
title: PHP Serialized Object Pattern in HTTP Request Body
id: 8c2e5d41-6a7b-4f39-9c21-4e8b7d2a5f90
status: experimental
description: Detects serialized PHP object signatures (O:<len>:"<class>") in web request bodies or query strings, a hallmark of PHP Object Injection attempts such as CVE-2026-124990. Requires web server or WAF request-body logging.
references:
- https://nvd.nist.gov/vuln/detail/CVE-2026-124990
author: Security Arsenal
date: 2026/01/15
tags:
- attack.initial_access
- attack.t1190
logsource:
category: webserver
product: linux
detection:
selection_serialized_obj:
-|re: O:\\d+:"[A-Za-z0-9_\\\\]+":\\d+:\{
selection_serialized_arr:
- 'a%3A'
- 'O%3A'
condition: selection_serialized_obj or selection_serialized_arr
falsepositives:
- Rare; legitimate plugins occasionally pass serialized data, but URL-encoded object strings in front-end POST bodies are highly suspicious on LMS endpoints
level: critical
---
title: PHP or Script File Written to WordPress Uploads Directory
id: 1b7c9e03-2f5a-4d68-a734-9f0c3e6b8d12
status: experimental
description: Detects creation of executable script files in the WordPress uploads directory, a common post-exploitation artifact of PHP Object Injection and webshell deployment following CVE-2026-124990 exploitation.
references:
- https://nvd.nist.gov/vuln/detail/CVE-2026-124990
author: Security Arsenal
date: 2026/01/15
tags:
- attack.persistence
- attack.t1505.003
logsource:
category: file_event
product: linux
detection:
selection:
TargetFilename|contains:
- '/wp-content/uploads/'
TargetFilename|endswith:
- '.php'
- '.phtml'
- '.phar'
- '.php5'
- '.php7'
- '.inc'
filter_legit_plugins:
TargetFilename|contains:
- 'index.php'
condition: selection and not filter_legit_plugins
falsepositives:
- Some backup/migration plugins write PHP files to uploads; baseline per environment
level: critical
KQL — Microsoft Sentinel / Defender
If your WordPress hosts forward nginx/apache logs via the Syslog/CEF connector, or you ingest WAF logs (Cloudflare, Azure Front Door, ModSecurity), hunt for import-endpoint hits and serialized payloads. This query also pivots into post-exploitation process execution if the host runs Defender for Endpoint or a Sysmon-equivalent via AMA.
// Hunt 1: Requests to Masteriyo import endpoints + serialized object patterns in web logs
let Lookback = 14d;
union isfuzzy=true
(CommonSecurityLog
| where TimeGenerated > ago(Lookback)
| where RequestMethod =~ "POST"
| where RequestURL has_any ("admin-ajax.php", "wp-json/masteriyo", "masteriyo")
| where RequestURL has_any ("import", "course")
or AdditionalExtensions has_any ("O%3A", "a%3A", "O:\\")
| project TimeGenerated, SourceIP, RequestURL, RequestMethod, RequestPayload = AdditionalExtensions, DeviceAction, DestinationHostName),
(Syslog
| where TimeGenerated > ago(Lookback)
| where SyslogMessage has "POST"
| where SyslogMessage has_any ("admin-ajax.php", "wp-json/masteriyo")
| where SyslogMessage has_any ("masteriyo", "import")
| extend RequestLine = SyslogMessage
| project TimeGenerated, Computer, HostIP, RequestLine)
| summarize Hits = count(), FirstSeen = min(TimeGenerated), LastSeen = max(TimeGenerated)
by SourceIP, Computer
| where Hits > 3 or FirstSeen > ago(72h)
| order by LastSeen desc;
// Hunt 2: Post-exploitation — web server process spawning shells or writing scripts
DeviceProcessEvents
| where TimeGenerated > ago(14d)
| where InitiatingProcessFileName has_any ("php", "php-fpm", "apache2", "nginx", "httpd", "www-data")
| where FileName has_any ("sh", "bash", "dash", "curl", "wget", "python", "perl", "base64", "nc", "ncat")
| project TimeGenerated, DeviceName, InitiatingProcessFileName, FileName, ProcessCommandLine, InitiatingProcessCommandLine, AccountName
| order by TimeGenerated desc;
Tuning note: Hunt 1 keys on volume and recency from a single source IP — automated scanners hit these endpoints repeatedly. A single POST to the import endpoint from an IP that has never authenticated to wp-admin is a high-fidelity lead.
Velociraptor VQL
For endpoint validation on suspected-compromised WordPress hosts, hunt for webshells planted in uploads and recently-modified PHP files outside normal plugin/theme update windows.
-- Hunt: Suspicious PHP files in WordPress uploads and recently modified web content
-- Artifact target: Linux WordPress hosts (adjust webroot as needed)
LET webroot = '/var/www/html'
LET recent_php = SELECT FullPath, Size, Mtime, Ctime,
hash(path=FullPath).SHA256 AS SHA256
FROM glob(globs=webroot + '/wp-content/uploads/**/*.php')
WHERE Mtime > (now() - 1209600) -- last 14 days
LET recent_mods = SELECT FullPath, Size, Mtime,
hash(path=FullPath).SHA256 AS SHA256
FROM glob(globs=webroot + '/wp-content/**/*.php')
WHERE Mtime > (now() - 604800) -- last 7 days
AND NOT FullPath =~ 'wp-content/plugins|wp-content/themes/.*/(style|index)'
SELECT * FROM recent_php
UNION ALL
SELECT * FROM recent_mods
ORDER BY Mtime DESC
Complement this with a listener check to catch reverse shells spawned from PHP-FPM workers:
-- Hunt: Web server processes with unexpected outbound connections
SELECT Pid, Name, CommandLine, Exe
FROM pslist()
WHERE Name =~ 'php|apache|nginx|httpd'
AND CommandLine =~ 'bash|sh -|nc |curl|wget'
Remediation & Verification Script
Run the following on each WordPress host (adjust WP_ROOT and the WP-CLI user). It inventories the plugin version, checks the two dangerous configuration flags, verifies patch state, sweeps for webshell artifacts, and audits for rogue admin accounts — the four things you need answered in the first hour.
#!/bin/bash
# CVE-2026-124990 - Masteriyo LMS PHP Object Injection: verify & harden
# Run as root or a user with WP-CLI access to the WordPress install.
set -euo pipefail
WP_ROOT="/var/www/html"
WP_USER="www-data"
WP="sudo -u ${WP_USER} wp --path=${WP_ROOT}"
echo "=== [1] Masteriyo LMS plugin status ==="
if $WP plugin is-installed masteriyo-lms 2>/dev/null; then
VER=$($WP plugin get masteriyo-lms --field=version 2>/dev/null)
echo "Masteriyo LMS installed, version: ${VER}"
# Vulnerable: <= 3.5.1. Flag anything not above it.
if [ "$(printf '%s\n' "3.5.1" "${VER}" | sort -V | head -n1)" = "${VER}" ] && [ "${VER}" != "3.5.1" ]; then
echo "[!] Version ${VER} is BELOW 3.5.1 comparison floor - treat as VULNERABLE until confirmed patched."
elif [ "${VER}" = "3.5.1" ] || [ "$(printf '%s\n' "${VER}" "3.5.1" | sort -V | head -n1)" != "${VER}" ]; then
echo "[!] POTENTIALLY VULNERABLE: ${VER} <= 3.5.1. Update immediately."
else
echo "[OK] Version ${VER} is above 3.5.1 - confirm it includes the vendor fix."
fi
else
echo "[OK] Masteriyo LMS not installed on this site."
fi
echo ""
echo "=== [2] Dangerous configuration flags ==="
# These options gate unauthenticated exploitability. If both are true, assume exposed.
for opt in masteriyo_instructor_registration masteriyo_guest_checkout; do
$WP option get "${opt}" 2>/dev/null && echo " ^ review: ${opt}" || echo " ${opt}: not set"
done
$WP option get enable_instructor_registration 2>/dev/null || true
$WP option get enable_guest_checkout 2>/dev/null || true
echo ""
echo "=== [3] Webshell sweep: PHP files under uploads (last 30 days) ==="
find "${WP_ROOT}/wp-content/uploads" -type f \( -name '*.php' -o -name '*.phtml' -o -name '*.phar' \) \
-mtime -30 -not -name 'index.php' -ls 2>/dev/null || echo " none found"
echo ""
echo "=== [4] Recently modified plugin/theme PHP (last 7 days) ==="
find "${WP_ROOT}/wp-content" -type f -name '*.php' -mtime -7 \
-not -path '*/cache/*' -printf '%TY-%Tm-%Td %TH:%TM %p\n' 2>/dev/null | sort -r | head -50
echo ""
echo "=== [5] Rogue administrator account audit ==="
$WP user list --role=administrator --fields=ID,user_login,user_email,user_registered 2>/dev/null
echo ""
echo "=== [6] Access log hits on import endpoints (last 7 days) ==="
for LOG in /var/log/nginx/access.log /var/log/apache2/access.log /var/log/httpd/access_log; do
[ -f "${LOG}" ] && grep -Ei 'masteriyo|admin-ajax' "${LOG}" | grep -i 'import' | tail -20
done
echo "=== Done. Review output and escalate any hits to IR. ==="
Remediation
- Update Masteriyo LMS immediately to the latest release beyond 3.5.1 via the WordPress admin dashboard or WP-CLI (
wp plugin update masteriyo-lms). Confirm the installed version against the plugin's official changelog and the NVD entry for CVE-2026-124990. If the vendor has not yet shipped a fixed release at the time you read this, treat mitigations 2–4 as mandatory, not optional. - Close the exploit preconditions. Set
enable_instructor_registrationandenable_guest_checkouttofalsein Masteriyo settings until patched. These two flags are the gate for unauthenticated reachability — disabling them collapses the attack surface from "anyone on the internet" to authenticated users. - WAF/virtual patching. Deploy rules blocking (a) POST bodies containing PHP serialized object signatures (
O:\d+:"...":\d+:{) to any endpoint, and (b) unauthenticated requests to Masteriyo import endpoints (admin-ajax.phpwith Masteriyo import actions,/wp-json/masteriyo/*import routes). Cloudflare, ModSecurity (OWASP CRS with paranoia level covering deserialization), and AWS WAF all support this pattern class. - Harden the uploads directory. Deny PHP execution under
/wp-content/uploads/via nginxlocationblock or Apache.htaccess. This does not stop object injection, but it kills the most common webshell follow-through. - Assume compromise on exposed sites. If the plugin was ≤3.5.1 with both flags enabled since disclosure: run the verification script above, audit administrator accounts, review
wp-content/uploadsfor script files, checkwp-config.phpintegrity, rotate all admin credentials and WordPress salts/keys (wp config shuffle-salts), and review access logs for import-endpoint hits from unknown IPs. - Institutionalize the fix. Add WordPress plugin inventory to your vulnerability management program with a defined SLA for critical (CVSS ≥ 9.0) unauthenticated flaws — 72 hours maximum. Enable automatic plugin updates for non-revenue-critical sites, and monitor CISA KEV daily for a CVE-2026-124990 listing, which would trigger federal BOD 22-01 remediation deadlines for applicable organizations.
PHP Object Injection in WordPress plugins is a solved problem on the offensive side — gadget chains are public, scanners are automated, and the time-to-exploit after disclosure is measured in days. The only variable defenders control is exposure window. Shrink it.
Related Resources
Security Arsenal Penetration Testing Services AlertMonitor Platform Book a SOC Assessment vulnerability-management Intel Hub
Is your security operations ready?
Get a free SOC assessment or see how AlertMonitor cuts through alert noise with automated triage.