Opens in a new tab
Published : November 15, 2026

CVE-2026-27544: QA Assistants – Driven by data <= 5.2.0.0 Unauthenticated Remote Code Execution PoC, Patch Analysis & Rule

Severity Critical (CVSS 9.8)
CWE 94
Vulnerable Version 5.2.0.0
Patched Version 5.2.0.1
Disclosed August 10, 2026

Analysis Overview

Atomic Edge analysis of CVE-2026-27544: This is an unauthenticated Remote Code Execution vulnerability in the QA Assistants – Driven by data WordPress plugin, affecting all versions up to and including 5.2.0.0. The flaw resides in the plugin’s cron processing and view replay components, which use the WordPress filesystem API to write and read PHP files without proper sanitization. An attacker can inject malicious PHP code that is later executed, leading to full server compromise. The CVSS score is 9.8 (Critical) with CWE-94 (Improper Control of Generation of Code).

Root Cause: The vulnerability stems from unsafe use of `$wp_filesystem->put_contents()` and `$wp_filesystem->get_contents()` in class-qahm-cron-proc.php and class-qahm-view-replay.php. Specifically, in class-qahm-cron-proc.php, lines around 2572, 2602, and 3190 write attacker-influenced data (e.g., `$p_str`, `$e_str`, `$c_str`) to `.php` files (e.g., `$file_p_done`, `$file_e_done`, `$file_c_done`) without validating or escaping the content. These files are stored in a predictable directory and later included or read, allowing PHP code execution if the data contains PHP tags. Similarly, lines 3953, 3977, and 4001 read from these files with `get_contents()`, and class-qahm-view-replay.php line 63 reads `$event_tsv` from a file path. The lack of content sanitization before writing to executable files is the core issue.

Exploitation: An unauthenticated attacker can send crafted HTTP requests to the plugin’s endpoints that trigger the cron processing or view replay functionality. For example, the attacker may manipulate parameters that are logged as heatmap data (e.g., mouse movements, clicks) which are then serialized and written to the `.php` files. By injecting PHP code such as “ into these parameters, the attacker can cause the plugin to write a webshell to a known location (e.g., within the WordPress uploads directory or plugin’s raw data directory). Subsequent requests to that file execute arbitrary commands. The exact endpoint is likely a public AJAX action or REST route used for data collection, such as `admin-ajax.php?action=qahm_record_event` or similar, but the diff does not reveal the exact action name; however, the vulnerable code path is reachable without authentication because the plugin processes raw data from public visitors.

Patch Analysis: The patch replaces direct calls to `$wp_filesystem->put_contents()` and `$wp_filesystem->get_contents()` with wrapper methods `$this->wrap_put_contents()` and `$this->wrap_get_contents()`. These wrappers presumably add sanitization or validation to prevent PHP code injection. The version is bumped from 5.2.0.0 to 5.2.0.1. The before behavior allowed raw data to be written to `.php` files; after the patch, the wrappers likely strip or encode PHP tags, or enforce that file contents are safe for storage. This mitigates the RCE by ensuring that even if attacker data reaches the file write, it cannot contain executable PHP code.

Impact: Successful exploitation allows unauthenticated attackers to execute arbitrary PHP code on the server, leading to complete site compromise. Attackers can read sensitive data (e.g., wp-config.php), create admin accounts, install backdoors, or pivot to other systems. The vulnerability is critical due to its remote, unauthenticated nature and the high impact of RCE.

Differential between vulnerable and patched code

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

Code Diff
--- a/qa-heatmap-analytics/class-qahm-cron-proc.php
+++ b/qa-heatmap-analytics/class-qahm-cron-proc.php
@@ -2572,7 +2572,7 @@
 											}
 										}
 										if ( $p_str !== '' ) {
-											$wp_filesystem->put_contents( $file_p_done, $p_str );
+											$this->wrap_put_contents( $file_p_done, $p_str );
 											$wp_filesystem->delete( $file_p );
 										}
 									}
@@ -2602,7 +2602,7 @@
 											}
 										}
 										if ( $e_str !== '' ) {
-											$wp_filesystem->put_contents( $file_e_done, $e_str );
+											$this->wrap_put_contents( $file_e_done, $e_str );
 											$wp_filesystem->delete( $file_e );
 										}
 									}
@@ -3190,7 +3190,7 @@
 								}
 								if ( ! empty( $c_str ) ) {
 									// update raw-c file
-									$wp_filesystem->put_contents( $file_c_done, $c_str );
+									$this->wrap_put_contents( $file_c_done, $c_str );
 									$wp_filesystem->delete( $file_c );
 								}
 							}
@@ -3953,7 +3953,7 @@
 									$p_str  = '';
 									$file_p = $raw_dir . $raw_name . '-p-done' . '.php';
 									if ( $wp_filesystem->exists( $file_p ) ) {
-										$p_str = $wp_filesystem->get_contents( $file_p );
+										$p_str = $this->wrap_get_contents( $file_p );
 									} elseif ( $before_yesterday ) {
 										foreach ( $raw_p_data_ary as $raw_p_data ) {
 											if ( (int) $newary[ $idx ]['pv_id'] !== (int) $raw_p_data['pv_id'] ) {
@@ -3977,7 +3977,7 @@
 									$c_str  = '';
 									$file_c = $raw_dir . $raw_name . '-c-done' . '.php';
 									if ( $wp_filesystem->exists( $file_c ) ) {
-										$c_str = $wp_filesystem->get_contents( $file_c );
+										$c_str = $this->wrap_get_contents( $file_c );
 									} elseif ( $before_yesterday ) {
 										foreach ( $raw_c_data_ary as $raw_c_data ) {
 											if ( (int) $newary[ $idx ]['pv_id'] !== (int) $raw_c_data['pv_id'] ) {
@@ -4001,7 +4001,7 @@
 									$e_str  = '';
 									$file_e = $raw_dir . $raw_name . '-e-done' . '.php';
 									if ( $wp_filesystem->exists( $file_e ) ) {
-										$e_str = $wp_filesystem->get_contents( $file_e );
+										$e_str = $this->wrap_get_contents( $file_e );
 									} elseif ( $before_yesterday ) {
 										foreach ( $raw_e_data_ary as $raw_e_data ) {
 											if ( (int) $newary[ $idx ]['pv_id'] !== (int) $raw_e_data['pv_id'] ) {
--- a/qa-heatmap-analytics/class-qahm-view-replay.php
+++ b/qa-heatmap-analytics/class-qahm-view-replay.php
@@ -63,7 +63,7 @@
 			return null;
 		}

-		$event_tsv = $wp_filesystem->get_contents( $path );
+		$event_tsv = $this->wrap_get_contents( $path );
 		$event_ary = $this->convert_tsv_to_array( $event_tsv );

 		// バージョンチェック
--- a/qa-heatmap-analytics/qahm.php
+++ b/qa-heatmap-analytics/qahm.php
@@ -5,7 +5,7 @@
 Description: Discover insights with QA Assistants — your platform for data-driven assistants that analyze sites from different angles.
 Author: QuarkA
 Author URI: https://quarka.org/
-Version: 5.2.0.0
+Version: 5.2.0.1
 Text Domain: qa-heatmap-analytics
 Requires at least: 5.9
 Tested up to: 6.9

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:20262754,phase:2,deny,status:403,chain,msg:'CVE-2026-27544 via QA Assistants AJAX RCE',severity:'CRITICAL',tag:'CVE-2026-27544'"
  SecRule ARGS_POST:action "@streq qahm_record_event" "chain"
    SecRule ARGS_POST:page_url "@rx <?php" "t:none"

Frequently Asked Questions

Atomic Edge WAF security layer inspecting website traffic.

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

Trusted by Developers & Organizations

Trusted by Developers
Black & McDonald logo representing Enterprise tier security and support for Atomic Edge WAF.Covenant House Toronto logo featuring a dove and text for Atomic Edge Enterprise planAlzheimer Society Canada logo representing trusted organizations and security partners.University of Toronto logo representing trusted organizations using Atomic Edge WAFSpecsavvers logo, trusted developers and organizations using Atomic Edge securityHarvard Medical School logo representing trusted organizations using Atomic Edge WAF.