The NVD has published CVE-2026-13355, a CVSS 9.8 (CRITICAL) vulnerability in the Meta Box AIO plugin for WordPress, affecting all versions up to and including 3.11.0. This is a network-exploitable, unauthenticated privilege escalation to Administrator — the worst-case scenario for a WordPress plugin flaw.
What makes this vulnerability particularly dangerous is that it is a chained flaw spanning two components of the plugin (mb-frontend-submission and mb-user-profile), meaning the individual weaknesses look benign in isolation but combine into a full site takeover. Meta Box is one of the most widely deployed custom-field frameworks in the WordPress ecosystem, and the AIO bundle ships the frontend submission and user profile modules to a large installed base. If your organization — or any client you manage — runs WordPress with Meta Box AIO, treat this as a patch-now event.
Technical Analysis
Affected Products and Versions
| Item | Detail |
|---|---|
| Product | Meta Box AIO (WordPress plugin) |
| Affected versions | ≤ 3.11.0 (all versions up to and including) |
| Components | mb-frontend-submission, mb-user-profile |
| CVE | CVE-2026-13355 |
| CVSS v3.1 | 9.8 (CRITICAL) — Vector: NETWORK |
| Authentication required | None |
| Reference | https://nvd.nist.gov/vuln/detail/CVE-2026-13355 |
How the Attack Chain Works (Defender's View)
The exploit chains two missing authorization checks:
-
Object ID override via GET parameter. The
populate_via_query_string()function in themb-frontend-submissioncomponent unconditionally overrides the form's targetobject_idusing the value of the GET parameterrwmb_frontend_field_object_id. There is no authorization or ownership check — an attacker can point the frontend submission form at any post or page ID on the site, including content they have no rights to modify. -
Missing capability check in form processing. The plugin's
Form::process()method — which actually commits submitted data — lacks theuser_can_edit()check that is present inForm::render(). In other words, the code checks permissions when displaying the form, but not when processing the submission. This is a classic broken access control pattern (CWE-862, Missing Authorization): the gate exists at the front door but not at the vault. -
Arbitrary content overwrite and shortcode injection. Using
wp_update_post(), the attacker overwrites thepost_contentof any page with an arbitrary shortcode. Because shortcodes execute server-side when the page renders, this converts a content-modification bug into code/pathway execution within WordPress's trust boundary. -
Privilege escalation via mb-user-profile. The injected shortcode interacts with the
mb-user-profilemodule, which handles user registration/profile fields — giving the attacker a route to create or modify a user account with Administrator role, completing the unauthenticated-to-admin chain.
Exploitation Requirements and Status
- Authentication: None required. Any remote, unauthenticated client can reach the vulnerable code path as long as a frontend submission form is published on the site.
- Complexity: Low — the object_id override is a single GET parameter, and the processing path requires no race conditions or special conditions.
- Exploitation status: At time of writing, this is newly published via NVD. WordPress plugin flaws of this class (unauthenticated privilege escalation) historically move to in-the-wild exploitation within days to hours of public disclosure — see the exploitation velocity of comparable WordPress plugin CVEs in 2025. Defenders should operate under the assumption that scanning for
rwmb_frontend_field_object_idhas already begun. Monitor the CISA Known Exploited Vulnerabilities catalog for addition.
Why This Pattern Keeps Recurring
The render/process authorization asymmetry is a recurring WordPress plugin anti-pattern. Developers correctly gate the UI (current_user_can() before rendering) but assume the form handler will only ever be reached by users who saw the form. Automated scanners and manual researchers specifically hunt for handler functions that process state-changing requests without re-validating capabilities. Expect more CVEs of this class in 2026; build your detection strategy around the behavior (unauthenticated state-changing requests to plugin handlers), not just this one signature.
Detection & Response
The highest-fidelity detection opportunity is in web server access logs: the attack requires the attacker-controlled GET parameter rwmb_frontend_field_object_id to appear in the request URI. Any occurrence of this parameter in production logs — especially from sources that should never be interacting with frontend submission forms — is a strong indicator of probing or exploitation. Secondary signals include unexpected post_content modifications and new Administrator account creation.
Sigma Rules
---
title: Meta Box AIO CVE-2026-13355 Object ID Override Attempt
id: 3f9c1a72-6b8e-4d21-9f4a-2c7e5b8d1a63
status: experimental
description: Detects requests containing the rwmb_frontend_field_object_id GET parameter used to override the target object_id in the Meta Box AIO mb-frontend-submission component (CVE-2026-13355). Presence of this parameter in access logs indicates probing or active exploitation of the unauthenticated privilege escalation chain.
references:
- https://nvd.nist.gov/vuln/detail/CVE-2026-13355
author: Security Arsenal
date: 2026/04/06
tags:
- attack.initial_access
- attack.t1190
logsource:
category: webserver
detection:
selection:
cs-uri-query|contains: 'rwmb_frontend_field_object_id'
falsepositives:
- Rare; legitimate Meta Box frontend submissions populate object_id server-side and do not normally place this parameter in client-controlled query strings
level: high
---
title: Meta Box AIO Frontend Submission Form Processed With Injected Shortcode Content
id: 8a2e4b61-1c7d-4f39-b5e2-9d3a6c1f8e47
status: experimental
description: Detects POST requests to WordPress pages hosting Meta Box frontend submission forms where the query string carries an attacker-supplied object ID targeting administrative or high-value content, consistent with the Form::process() missing authorization check in CVE-2026-13355.
references:
- https://nvd.nist.gov/vuln/detail/CVE-2026-13355
author: Security Arsenal
date: 2026/04/06
tags:
- attack.privilege_escalation
- attack.t1068
- attack.t1190
logsource:
category: webserver
detection:
selection_method:
cs-method: 'POST'
cs-uri-query|contains: 'rwmb_frontend_field_object_id='
selection_shortcode:
cs-uri-query|contains:
- 'mb_user_profile'
- '[mb_user_profile'
condition: selection_method or selection_shortcode
falsepositives:
- Site administrators testing frontend submission forms during development
level: critical
KQL (Microsoft Sentinel / Defender)
The query below hunts both IIS W3C logs (for Windows-hosted WordPress) and Apache/Nginx logs ingested via Syslog/CEF, plus a correlated hunt for newly created privileged accounts on the host following a suspicious request.
// Hunt 1: Requests carrying the CVE-2026-13355 object_id override parameter
let SuspiciousParam = "rwmb_frontend_field_object_id";
let IISHits = W3CIISLog
| where csUriQuery has SuspiciousParam
| project TimeGenerated, cIP, sSiteName, csMethod, csUriStem, csUriQuery, scStatus, csUserAgent, Computer
| extend Source = "IIS";
let SyslogHits = Syslog
| where SyslogMessage has SuspiciousParam
| project TimeGenerated, HostIP, Computer, ProcessName, SyslogMessage
| extend Source = "Syslog";
let CefHits = CommonSecurityLog
| where RequestURL has SuspiciousParam or AdditionalExtensions has SuspiciousParam
| project TimeGenerated, SourceIP, RequestMethod, RequestURL, DeviceAction, DeviceProduct, SourceHostName
| extend Source = "CEF";
union IISHits, SyslogHits, CefHits
| summarize FirstSeen=min(TimeGenerated), LastSeen=max(TimeGenerated), RequestCount=count()
by Source, cIP, SourceIP, csUriStem, csUserAgent
| order by RequestCount desc;
// Hunt 2: POST requests to frontend submission pages with object_id override,
// followed by admin-side activity from the same source IP within 1 hour
let Window = 1h;
let ExploitIPs = W3CIISLog
| where csMethod == "POST" and csUriQuery has "rwmb_frontend_field_object_id"
| extend ExploitTime = TimeGenerated
| summarize by cIP, ExploitTime;
W3CIISLog
| where csUriStem has_any ("/wp-admin/", "/wp-login.php", "user-new.php", "admin-ajax.php")
| join kind=inner (ExploitIPs) on cIP
| where TimeGenerated between (ExploitTime .. (ExploitTime + Window))
| project ExploitTime, FollowUpTime=TimeGenerated, cIP, csUriStem, csUriQuery, scStatus, csUserAgent
| order by ExploitTime asc;
Velociraptor VQL
WordPress typically runs on Linux hosts. This artifact hunts web server access logs directly on the endpoint for evidence of the override parameter, including rotated logs — critical because attackers will not clean up after themselves on the web tier.
-- Hunt web server access logs for CVE-2026-13355 object_id override attempts
LET log_files <= SELECT FullPath, Mtime, Size
FROM glob(globs=[
'/var/log/nginx/access.log*',
'/var/log/apache2/access.log*',
'/var/log/apache2/other_vhosts_access.log*',
'/var/log/httpd/access_log*',
'/var/log/nginx/*/access.log*'
])
WHERE Size > 0
SELECT FullPath, Mtime AS LogMtime,
parse_string_with_regex(
string=Line,
regex='^(?P<SrcIP>[0-9a-fA-F\\.:\\%]+) .*?\\\"(?P<Method>[A-Z]+) (?P<URI>[^\" ]*) (?P<Proto>[^\"]*)\\\" (?P<Status>[0-9]+)'
).SrcIP AS SourceIP,
parse_string_with_regex(
string=Line,
regex='^(?P<SrcIP>[0-9a-fA-F\\.:\\%]+) .*?\\\"(?P<Method>[A-Z]+) (?P<URI>[^\" ]*) (?P<Proto>[^\"]*)\\\" (?P<Status>[0-9]+)'
).Method AS Method,
parse_string_with_regex(
string=Line,
regex='^(?P<SrcIP>[0-9a-fA-F\\.:\\%]+) .*?\\\"(?P<Method>[A-Z]+) (?P<URI>[^\" ]*) (?P<Proto>[^\"]*)\\\" (?P<Status>[0-9]+)'
).URI AS RequestURI,
parse_string_with_regex(
string=Line,
regex='^(?P<SrcIP>[0-9a-fA-F\\.:\\%]+) .*?\\\"(?P<Method>[A-Z]+) (?P<URI>[^\" ]*) (?P<Proto>[^\"]*)\\\" (?P<Status>[0-9]+)'
).Status AS Status
FROM foreach(row=log_files,
query={
SELECT Line, FullPath FROM parse_lines(filename=FullPath)
WHERE Line =~ 'rwmb_frontend_field_object_id'
})
ORDER BY LogMtime DESC
Remediation and Verification Script
The following Bash script audits WordPress installations on a Linux host for the vulnerable Meta Box AIO version, checks access logs for exploitation indicators, and applies the update via WP-CLI. Run it on each web node (adapt the document root path as needed).
#!/usr/bin/env bash
# CVE-2026-13355 - Meta Box AIO <= 3.11.0 unauthenticated privilege escalation
# Audit and remediation helper. Run as root or a user with WP-CLI access.
set -euo pipefail
WP_ROOTS=("/var/www" "/srv/www" "/home")
WPCLI="wp --allow-root"
VULN_MAX="3.11.0"
echo "=== CVE-2026-13355 Meta Box AIO Audit ==="
# 1) Locate WordPress installs and check meta-box-aio version
find "${WP_ROOTS[@]}" -maxdepth 4 -name wp-config.php 2>/dev/null | while read -r cfg; do
site_dir=$(dirname "$cfg")
echo "[+] Checking site: $site_dir"
ver=$(cd "$site_dir" && $WPCLI plugin get meta-box-aio --field=version 2>/dev/null || echo "not-installed")
if [[ "$ver" == "not-installed" ]]; then
echo " meta-box-aio not present. Skipping."
continue
fi
echo " Installed meta-box-aio version: $ver"
if [[ "$(printf '%s\n%s\n' "$ver" "$VULN_MAX" | sort -V | head -n1)" == "$ver" ]] && [[ "$ver" != "$VULN_MAX" || "$ver" == "$VULN_MAX" ]]; then
if [[ "$ver" == "$VULN_MAX" || "$(printf '%s\n%s\n' "$ver" "$VULN_MAX" | sort -V | tail -n1)" == "$VULN_MAX" ]]; then
echo " [!] VULNERABLE (<= $VULN_MAX). Attempting update..."
(cd "$site_dir" && $WPCLI plugin update meta-box-aio) || {
echo " [!!] Update failed - DEACTIVATING plugin as emergency mitigation"
(cd "$site_dir" && $WPCLI plugin deactivate meta-box-aio)
}
new_ver=$(cd "$site_dir" && $WPCLI plugin get meta-box-aio --field=version 2>/dev/null || echo "unknown")
echo " Post-action version: $new_ver"
fi
else
echo " [OK] Version appears patched (> $VULN_MAX). Verify against vendor advisory."
fi
done
# 2) Hunt access logs for the exploit parameter (last 90 days of logs)
echo ""
echo "=== Hunting access logs for rwmb_frontend_field_object_id ==="
LOG_DIRS=("/var/log/nginx" "/var/log/apache2" "/var/log/httpd")
for d in "${LOG_DIRS[@]}"; do
[[ -d "$d" ]] || continue
echo "[+] Scanning $d"
zgrep -h -i "rwmb_frontend_field_object_id" "$d"/*access*.log* 2>/dev/null | \
awk '{print $1, $7}' | sort | uniq -c | sort -rn | head -50 || echo " No hits in $d"
done
# 3) Check for recently created administrator accounts (possible post-exploitation)
echo ""
echo "=== Auditing recent Administrator accounts ==="
find "${WP_ROOTS[@]}" -maxdepth 4 -name wp-config.php 2>/dev/null | while read -r cfg; do
site_dir=$(dirname "$cfg")
echo "[+] Site: $site_dir"
(cd "$site_dir" && $WPCLI user list --role=administrator \
--fields=ID,user_login,user_email,user_registered --format=table) 2>/dev/null || true
done
echo ""
echo "=== Done. Review any log hits and unfamiliar admin accounts immediately. ==="
Remediation
1. Update immediately. Upgrade Meta Box AIO to the latest release beyond 3.11.0 via the WordPress admin dashboard or WP-CLI (wp plugin update meta-box-aio). Verify the installed version after update — do not trust auto-update settings on production sites without confirmation. Given the CVSS 9.8 unauthenticated-to-admin impact, this should be treated with the same urgency as a CISA KEV-listed flaw; patch within 24 hours, not the next maintenance window.
2. If you cannot patch right now: Deactivate the Meta Box AIO plugin, or at minimum deactivate/remove the Meta Box Frontend Submission and MB User Profile extensions and unpublish any pages embedding [mb_frontend_form] or [mb_user_profile_*] shortcodes. As a compensating control, add a WAF rule blocking any request whose query string contains rwmb_frontend_field_object_id — for ModSecurity:
# ModSecurity WAF rule - block CVE-2026-13355 object_id override parameter
SecRule ARGS_GET_NAMES "@contains rwmb_frontend_field_object_id" \
"id:90013355,phase:1,deny,status:403,log,msg:'CVE-2026-13355 Meta Box AIO object_id override attempt'"
# Verify rule is active after reload:
apachectl -t && systemctl reload apache2
tail -f /var/log/apache2/error.log | grep 90013355
3. Hunt before you assume you're clean. Because this vulnerability requires no authentication and leaves a distinctive URI artifact, review web access logs for the past 90 days (or your retention window) for rwmb_frontend_field_object_id. Any hit warrants a full IR triage of the site.
4. Post-exploitation checks. If you find evidence of the parameter in logs: (a) audit wp_users / administrator role membership for unfamiliar or recently registered accounts; (b) diff post_content across high-value pages against backups for injected shortcodes such as [mb_user_profile_register] or unexpected shortcode blocks; (c) check for rogue plugins, mu-plugins, and modified theme files (functions.php is a favorite); (d) rotate all administrator credentials, WordPress salts/keys in wp-config.php, and any API keys stored in the database; (e) consider restoring from a known-good backup predating the first suspicious request.
5. Harden the platform going forward. Restrict the attack surface: disable plugin file editing (define('DISALLOW_FILE_EDIT', true); and ideally DISALLOW_FILE_MODS with deployment-managed updates), enforce MFA on all privileged accounts, put wp-admin behind IP allowlisting or SSO where feasible, and ensure your WordPress fleet is covered by a managed detection capability that ingests web access logs — the single most valuable telemetry source for this vulnerability class.
6. Verify at scale. If you manage multiple WordPress properties (agency, MSP, or enterprise multisite environments), inventory every site for Meta Box AIO and its bundled extensions — remember the vulnerable components ship inside the AIO bundle even when site owners believe they "only use custom fields."
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.