SecurityWeek has reported that a vulnerability in the Bricksforge plugin for WordPress, tracked as CVE-2026-85097, is being actively exploited in the wild. Successful exploitation can allow threat actors to take control of targeted WordPress websites — which in practice means arbitrary code execution under the web server context, persistent backdoor deployment, rogue administrator creation, and downstream compromise of every visitor and every integration that trusts that site.
If your organization runs WordPress sites — marketing properties, customer portals, e-commerce front ends — with the Bricksforge plugin installed, treat this as an emergency patch event, not a routine maintenance window. In-the-wild exploitation of WordPress plugin flaws compresses the defender's timeline to hours, not days. Attackers are scanning opportunistically at scale, and any unpatched instance reachable from the internet should be assumed to be targeted.
This post breaks down the threat, gives you concrete detection content for your SIEM and EDR stack, and lays out a remediation and post-compromise verification workflow.
Technical Analysis
Affected Product
- Product: Bricksforge (a WordPress plugin that extends the Bricks Builder page builder ecosystem)
- Platform: WordPress deployments (typically PHP on Linux/Apache/Nginx, but equally applicable to Windows/IIS-hosted WordPress and containerized deployments)
- Impact: Full site takeover — arbitrary code execution, content manipulation, credential theft, and pivot into hosting infrastructure
How These Attacks Typically Unfold (Defender's View of the Kill Chain)
While the full technical write-up on CVE-2026-85097 is still emerging, WordPress plugin takeover vulnerabilities exploited at scale follow a well-documented and highly predictable attack chain. Defenders should hunt for the entire chain, not just the initial request:
- Reconnaissance/scanning: Automated scanners enumerate
/wp-content/plugins/bricksforge/assets (e.g.,readme.txt, CSS/JS files) to fingerprint vulnerable installs. Expect high-volume GET requests with scanner user agents. - Exploitation request: Crafted HTTP requests (typically POST) hit WordPress AJAX (
/wp-admin/admin-ajax.php), REST API routes (/wp-json/), or plugin-specific endpoints under the Bricksforge path. Payloads frequently contain PHP code, base64-encoded blobs,eval,assert,system, or file-write primitives. - Webshell drop: Attackers write PHP webshells into world-accessible directories — most commonly
wp-content/uploads/,wp-content/uploads/<yyyy>/<mm>/, the plugin directory itself, or the webroot. - Persistence: Rogue WordPress administrator accounts (created via direct database manipulation or abuse of legitimate user-creation functions), malicious
mu-plugins, injected code intowp-config.php/functions.php, or cron/system-level persistence on the underlying host. - Post-exploitation: SEO spam injection, redirect malware for visitors, credential harvesting from
wp-config.php(database creds, API keys), lateral movement into adjacent virtual hosts, and in some campaigns, ransomware or cryptomining on the host.
Exploitation Status
- Status: Confirmed active exploitation in the wild per SecurityWeek reporting.
- Priority: Treat as an immediate remediation priority. Given active exploitation, monitor CISA's Known Exploited Vulnerabilities (KEV) catalog for inclusion, which would impose remediation deadlines for federal agencies and is a strong urgency signal for everyone else.
Detection & Response
The detections below target the observable behaviors of this class of attack: reconnaissance against the plugin path, exploit-style payloads in web requests, webshell deployment, and post-exploitation process activity from the web server context. Tune paths and process names to your stack (Apache vs. Nginx vs. IIS, PHP-FPM vs. mod_php).
Sigma Rules
---
title: Suspicious Requests Targeting Bricksforge WordPress Plugin
description: Detects reconnaissance and exploitation attempts against the Bricksforge WordPress plugin, associated with CVE-2026-85097 in-the-wild exploitation.
references:
- https://www.securityweek.com/bricksforge-wordpress-plugin-vulnerability-exploited-in-the-wild/
author: Security Arsenal
date: 2026/04/06
id: 3f8a1c92-7b44-4e5d-9a21-c6d8e2f5a7b3
status: experimental
tags:
- attack.initial_access
- attack.t1190
logsource:
category: webserver
detection:
selection_path:
cs-uri-stem|contains:
- '/wp-content/plugins/bricksforge/'
selection_payload:
cs-uri-query|contains:
- 'base64_decode'
- 'eval('
- 'assert('
- 'system('
- 'shell_exec'
- 'php://input'
- '../'
- 'cmd='
condition: selection_path and selection_payload
falsepositives:
- Legitimate plugin AJAX calls should be reviewed; encoded payloads in query strings against this plugin path are rare in normal operation
level: high
---
title: WordPress AJAX or REST Endpoint Exploitation Payload Patterns
description: Detects POST requests to WordPress admin-ajax.php or REST API routes containing PHP code execution or file manipulation payloads, consistent with WordPress plugin takeover attacks such as CVE-2026-85097.
references:
- https://www.securityweek.com/bricksforge-wordpress-plugin-vulnerability-exploited-in-the-wild/
author: Security Arsenal
date: 2026/04/06
id: 9c2e5d71-4a68-4f3b-b817-1d9f4a6c8e02
status: experimental
tags:
- attack.initial_access
- attack.t1190
logsource:
category: webserver
detection:
selection_endpoint:
cs-uri-stem|contains:
- '/wp-admin/admin-ajax.php'
- '/wp-json/'
selection_method:
cs-method: 'POST'
selection_payload:
cs-uri-query|contains:
- 'eval('
- 'base64_decode'
- 'file_put_contents'
- 'move_uploaded_file'
- 'wp_insert_user'
- 'add_action'
- '%3C%3Fphp'
- '<?php'
condition: selection_endpoint and selection_method and selection_payload
falsepositives:
- Some plugin update or form handlers use POST to these endpoints; payload strings are the discriminator
level: high
---
title: PHP Webshell Dropped in WordPress Uploads Directory
description: Detects creation of PHP files in WordPress uploads directories, a hallmark of webshell deployment following plugin exploitation such as CVE-2026-85097.
references:
- https://www.securityweek.com/bricksforge-wordpress-plugin-vulnerability-exploited-in-the-wild/
author: Security Arsenal
date: 2026/04/06
id: 5b1d7e34-8f29-4c6a-a543-2e8b9d1f7c40
status: experimental
tags:
- attack.persistence
- attack.t1505.003
logsource:
category: file_creation
product: linux
detection:
selection:
TargetFilename|contains:
- '/wp-content/uploads/'
TargetFilename|endswith:
- '.php'
- '.phtml'
- '.phar'
- '.php5'
- '.php7'
falsepositives:
- Rare; legitimate media uploads are not PHP files. Some migration/backup tooling may write PHP into uploads — whitelist known tooling
level: critical
KQL (Microsoft Sentinel / Defender)
This query hunts web access logs ingested into Sentinel (via W3CIISLog, CommonSecurityLog from a WAF/reverse proxy, or Syslog-ingested Apache/Nginx logs) for Bricksforge reconnaissance and exploit-pattern requests, then correlates with webshell-style file drops reported by Defender for Endpoint on the host.
// Hunt 1: Reconnaissance and exploitation attempts against Bricksforge (CVE-2026-85097)
let SuspiciousPayloads = dynamic(["base64_decode", "eval(", "assert(", "system(", "shell_exec", "file_put_contents", "<?php", "php://input", "../", "cmd="]);
let BricksforgePath = "/wp-content/plugins/bricksforge/";
union isfuzzy=true
(W3CIISLog
| where csUriStem has BricksforgePath or (csUriStem has_any ("/wp-admin/admin-ajax.php", "/wp-json/") and csMethod == "POST")
| where csUriQuery has_any (SuspiciousPayloads)
| project TimeGenerated, cIP, sIP, csMethod, csUriStem, csUriQuery, scStatus, csUserAgent, SourceTable="W3CIISLog"),
(CommonSecurityLog
| where RequestURL has BricksforgePath or (RequestURL has_any ("admin-ajax.php", "/wp-json/") and RequestMethod == "POST")
| where RequestURL has_any (SuspiciousPayloads)
| project TimeGenerated, cIP=SourceIP, sIP=DestinationIP, csMethod=RequestMethod, csUriStem=RequestURL, csUriQuery="", scStatus="", csUserAgent=RequestClientApplication, SourceTable="CommonSecurityLog")
| summarize FirstSeen=min(TimeGenerated), LastSeen=max(TimeGenerated), Requests=count(), DistinctURIs=dcount(csUriStem) by cIP, csUserAgent, SourceTable
| order by Requests desc;
// Hunt 2: Webshell drops and suspicious child processes from web server workers on WordPress hosts
DeviceFileEvents
| where FolderPath has "wp-content/uploads" and FileName endswith ".php" or FileName endswith ".phtml" or FileName endswith ".phar"
| project TimeGenerated, DeviceName, FolderPath, FileName, InitiatingProcessFileName, InitiatingProcessAccountName, SHA256
| join kind=leftouter (
DeviceProcessEvents
| where InitiatingProcessFileName has_any ("php", "php-fpm", "httpd", "apache2", "nginx", "w3wp.exe", "php-cgi.exe")
| where FileName has_any ("sh", "bash", "dash", "curl", "wget", "nc", "ncat", "python", "perl", "cmd.exe", "powershell.exe")
| project TimeGenerated, DeviceName, FileName, ProcessCommandLine, InitiatingProcessFileName, AccountName
) on DeviceName
| project TimeGenerated, DeviceName, FileName, FolderPath, ProcessCommandLine, InitiatingProcessFileName
| order by TimeGenerated desc;
Velociraptor VQL
Use this hunt artifact against WordPress hosts to surface recently written PHP files in upload directories (webshells), plus suspicious outbound connections and child processes from web server workers — the post-exploitation footprint of CVE-2026-85097 abuse.
-- Hunt: Bricksforge CVE-2026-85097 post-exploitation artifacts on WordPress hosts
-- 1) PHP files recently written into uploads (webshell indicator)
LET webshells = SELECT FullPath, Size, Mtime, Atime
FROM glob(globs="/var/www/**/wp-content/uploads/**/*.php")
WHERE Mtime > now() - 1209600 -- last 14 days, tune to your patch window
-- 2) Suspicious child processes spawned by web server / PHP workers
LET suspicious_procs = SELECT Pid, Ppid, Name, Exe, CommandLine, Username, CreateTime
FROM pslist()
WHERE Name =~ '(?i)^(sh|bash|dash|curl|wget|nc|ncat|socat|python|perl)'
AND getMember(item=getItem(field='Pid', member=Pid), field='Ppid') -- keep structure explicit
AND Exe =~ '(?i)(bin/(sh|bash)|bin/(curl|wget)|bin/(nc|ncat))'
-- 3) Outbound connections held by web server/PHP processes (webshell C2 / reverse shells)
LET websrv_net = SELECT Pid, Name, LocalAddress, LocalPort, RemoteAddress, RemotePort, Status
FROM netstat()
WHERE Name =~ '(?i)(php-fpm|php|apache2|httpd|nginx)'
AND Status =~ '(?i)ESTABLISHED'
AND NOT RemotePort in (80, 443, 3306, 6379, 11211) -- exclude normal app/db/cache traffic
SELECT * FROM webshells
UNION ALL SELECT * FROM suspicious_procs
UNION ALL SELECT * FROM websrv_net
Remediation / Verification Script
Run this Bash script on each WordPress host (or adapt into your configuration management/Ansible pipeline) to check the Bricksforge installation status, hunt for webshells and rogue admin artifacts, and enumerate recently modified PHP files. It does not patch for you — it gives you the ground truth to drive the patch-and-verify cycle.
#!/bin/bash
# CVE-2026-85097 - Bricksforge exposure and compromise verification script
# Run as root or with sudo on each WordPress host. Adjust WP_ROOT as needed.
WP_ROOT="/var/www/html"
echo "=== [1] Bricksforge plugin presence and version ==="
if [ -d "$WP_ROOT/wp-content/plugins/bricksforge" ]; then
echo "[!] Bricksforge IS installed. Version info:"
grep -i "Version:" "$WP_ROOT/wp-content/plugins/bricksforge/bricksforge.php" 2>/dev/null || echo " Main plugin file not found at expected path"
grep -i "Stable tag:" "$WP_ROOT/wp-content/plugins/bricksforge/readme.txt" 2>/dev/null
else
echo "[OK] Bricksforge plugin directory not found under $WP_ROOT"
fi
echo ""
echo "=== [2] PHP files inside uploads (webshell indicator) ==="
find "$WP_ROOT/wp-content/uploads" -type f \( -name "*.php" -o -name "*.phtml" -o -name "*.phar" -o -name "*.php5" -o -name "*.php7" \) -printf "%T+ %p\n" 2>/dev/null | sort -r | head -50
echo ""
echo "=== [3] PHP files modified in the last 14 days site-wide ==="
find "$WP_ROOT" -type f -name "*.php" -mtime -14 -printf "%T+ %p\n" 2>/dev/null | sort -r | head -80
echo ""
echo "=== [4] Suspicious strings in web root (webshell markers) ==="
grep -rlE "(eval\(base64_decode|assert\(\$_|system\(\$_(GET|POST|REQUEST)|shell_exec\(\$_|passthru\(\$_)" "$WP_ROOT" 2>/dev/null | head -30
echo ""
echo "=== [5] .htaccess integrity (redirect malware check) ==="
find "$WP_ROOT" -name ".htaccess" -mtime -30 -printf "%T+ %p\n" 2>/dev/null
echo ""
echo "=== [6] Unexpected established connections from web/PHP processes ==="
ss -tnp 2>/dev/null | grep -E "php-fpm|apache2|httpd|nginx" | grep -vE ":(80|443|3306|6379|11211)\s" | head -30
echo ""
echo "=== [7] Web server processes spawning shells/tools ==="
ps -eo pid,ppid,user,comm,args --forest 2>/dev/null | grep -E "(php-fpm|apache2|httpd|nginx)" -A 2 | grep -E "(sh|bash|curl|wget|nc|python|perl)" | head -20
echo ""
echo "=== Review complete. Any hits in sections 2-4 and 6-7 warrant IR escalation. ==="
Remediation
Immediate actions (next 24 hours):
- Update Bricksforge immediately. Apply the latest vendor release that addresses CVE-2026-85097 via the WordPress admin dashboard (Plugins → Installed Plugins) or WP-CLI (
wp plugin update bricksforge). Confirm the installed version against the patched version cited in the vendor advisory and the SecurityWeek report: https://www.securityweek.com/bricksforge-wordpress-plugin-vulnerability-exploited-in-the-wild/ - If you cannot patch immediately, deactivate the plugin.
wp plugin deactivate bricksforge. A broken page-builder feature set is a business inconvenience; a site takeover is a business incident. - Assume compromise on unpatched, internet-exposed instances. Run the verification script above. WordPress plugin exploitation is automated and fast — an unpatched site exposed since public disclosure has likely been scanned and possibly breached.
Post-compromise verification (if any indicators fire):
- Audit WordPress users for rogue administrator accounts:
wp user list --role=administrator. Cross-reference against your known admin roster and checkuser_registeredtimestamps. - Rotate credentials that a site takeover exposes: WordPress admin passwords, database credentials in
wp-config.php, any API keys/secrets stored in plugin settings, and hosting control panel credentials. - Restore from a known-good backup if webshells or unauthorized code modifications are confirmed. Cleaning a compromised WordPress install by hand is notoriously unreliable — attackers plant redundant persistence (mu-plugins, injected
functions.php, cron entries, database-stored payloads). - Check file integrity against clean sources:
wp core verify-checksumsandwp plugin verify-checksums --all(for plugins hosted on wordpress.org).
Structural hardening (this week):
- Block PHP execution in uploads. Add deny rules in Nginx/Apache or an
.htaccesswithphp_flag engine offfor/wp-content/uploads/. This single control neutralizes the most common webshell deployment path. - Deploy or tune a WAF (ModSecurity with OWASP CRS, Cloudflare, or equivalent) with rules covering PHP code injection patterns in request bodies and query strings targeting
admin-ajax.phpand/wp-json/. - Restrict
admin-ajax.phpand XML-RPC exposure where business logic allows, and enforce IP allowlisting or SSO for/wp-admin/. - Instrument logging and forwarding. Ensure web access logs, PHP-FPM logs, and auth logs flow to your SIEM so the detections above actually have telemetry to chew on. A WordPress site with no log forwarding is a black box.
- Establish an emergency patch SLA for WordPress plugins under active exploitation. This is the third time this year most teams will have done this dance — codify it. KEV-tracked and actively exploited plugin CVEs should carry a 24–48 hour patch SLA, not a monthly maintenance window.
Watch for CISA KEV inclusion. Actively exploited vulnerabilities like CVE-2026-85097 are prime candidates for the KEV catalog. If added, federal civilian agencies face binding remediation deadlines — and private-sector teams should treat KEV inclusion as a forcing function for their own SLAs.
The Bottom Line
CVE-2026-85097 is not a theoretical risk — it is being exploited now, against real sites, at scale. WordPress plugin takeovers are among the highest-volume initial access vectors we see in IR engagements, and they routinely serve as the foothold for follow-on activity well beyond defacement: credential theft, supply-chain abuse of site visitors, and pivoting into hosting infrastructure. Patch Bricksforge today, hunt for the post-exploitation artifacts with the queries above, and fix the structural gaps — uploads execution, WAF coverage, log forwarding — that make these incidents worse than they need to be.
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.