Back to Intelligence

CVE-2026-125294: Critical WordPress Nexter Blocks Pro Privilege Escalation — Unicode Denylist Bypass Detection and Remediation

SA
Security Arsenal Team
November 21, 2026
12 min read

NVD has published CVE-2026-125294, a CVSS 9.8 (Critical), network-exploitable vulnerability in the Nexter Blocks Pro plugin for WordPress, affecting all versions up to and including 5.0.10. The flaw allows an unauthenticated remote attacker to achieve unauthorized privilege gain — in practical terms, full WordPress administrator access — through the plugin's tpgb_ajax_register_user() function.

What makes this bug genuinely interesting — and genuinely dangerous — is the mechanism. This is not a missing authorization check or a garden-variety SQL injection. It is a byte-level denylist bypass using Unicode look-alike characters, which succeeds because of a mismatch between how PHP compares strings (bytes) and how MySQL compares them (collation-aware, accent-insensitive). Attackers who understand this class of bug move fast, and WordPress privilege escalation flaws are routinely weaponized within days of public disclosure for mass site takeover, SEO poisoning, and web shell deployment. If Nexter Blocks Pro is anywhere in your WordPress fleet, treat this as a patch-now event.

Affected Products and Versions

  • Product: Nexter Blocks Pro plugin for WordPress (POSIMYTH Innovations)
  • Affected versions: All versions up to and including 5.0.10
  • Vulnerable component: tpgb_ajax_register_user() AJAX handler, specifically its handling of the tpgb_acf_key[] and tpgb_acf[] request parameters
  • CVE: CVE-2026-125294 — CVSS 3.1 score 9.8 (Critical), vector: Network / no privileges required / no user interaction
  • Reference: NVD — CVE-2026-125294

Any WordPress site running this plugin where the registration AJAX endpoint is reachable is exposed. Because the attack is unauthenticated and requires no user interaction, internet-facing sites are directly exploitable with a single crafted HTTP request.

How the Vulnerability Works (Defender's View)

WordPress stores each user's role and capabilities in the wp_usermeta table under the meta key wp_capabilities (prefixed by the table prefix, e.g. wp_). If an attacker can write an arbitrary user meta key/value pair during registration — for example, wp_capabilities = a:1:{s:13:"administrator";b:1;} — they have just minted themselves an administrator account. Plugin developers know this, which is why Nexter Blocks Pro attempts to denylist dangerous meta keys like wp_capabilities when processing its ACF-style registration parameters tpgb_acf_key[] and tpgb_acf[].

The failure is in how the denylist is enforced:

  1. Byte-level matching in PHP. The denylist check compares the submitted key against blocked strings using byte-level (ASCII) pattern matching. A key submitted as wp_capabilities is correctly blocked.
  2. Unicode homoglyph substitution. The attacker instead submits a visually identical but byte-different key such as ẇp_çapabilities, using characters like U+1E87 (ẇ) and U+00E7 (ç). In UTF-8, ẇ is the byte sequence E1 BA 87 and ç is C3 A7. Neither matches the ASCII denylist pattern for w (0x77) or c (0x63), so the check passes.
  3. Collation collapse in MySQL. The key is written to and later read from wp_usermeta, whose columns typically use WordPress's default accent-insensitive collations — utf8mb4_unicode_ci or utf8mb4_0900_ai_ci. Under these collations, ẇ compares equal to w and ç compares equal to c. When WordPress executes SELECT meta_value FROM wp_usermeta WHERE meta_key = 'wp_capabilities', the database happily returns the attacker-controlled row stored under the decorated key ẇp_çapabilities.
  4. Privilege gain. WordPress loads the attacker's serialized capabilities array, sees the administrator role, and the newly registered account is now a full admin — able to install plugins, edit theme files, drop web shells, and pivot to the underlying host.

The exploitation chain requires nothing more than an HTTP POST to /wp-admin/admin-ajax.php with the plugin's registration action and the crafted tpgb_acf_key[]/tpgb_acf[] parameters. No credentials, no session, no special timing. This is why the CVSS vector scores at the ceiling for impact.

Why this class of bug keeps recurring

We've seen this same comparison-context mismatch pattern across the industry for years: a filter written in one layer of the stack (application byte comparison) being invalidated by the semantics of another layer (database collation, filesystem normalization, URL decoding). For defenders, the lesson is that denylists that operate on raw bytes are fundamentally fragile wherever a downstream interpreter applies normalization. Any hunt you build here generalizes: watch for non-ASCII bytes in parameter names that map to security-sensitive identifiers.

Exploitation Status

As of this writing, CVE-2026-125294 is publicly documented through NVD with the vulnerable function and bypass mechanics described in detail — which effectively hands a working exploitation recipe to any competent attacker. We have not seen confirmation of inclusion in the CISA Known Exploited Vulnerabilities catalog or vendor-confirmed mass exploitation at time of publication, but given that (a) the attack is unauthenticated and single-request, (b) WordPress privilege escalations are among the fastest-weaponized vulnerability classes, and (c) the technique is now fully public, you should operate under the assumption that scanning and exploitation are imminent or already underway. Verify against the CISA KEV catalog as part of your patch SLA tracking.

Detection and Threat Hunting

Detection here centers on three observables: (1) HTTP requests to the plugin's registration endpoint carrying the ACF parameters, (2) non-ASCII / percent-encoded Unicode bytes in those parameter values, and (3) the downstream artifact — a usermeta row whose key is collation-equal but not byte-equal to wp_capabilities, or an unexpected new administrator account.

Sigma Rules

These rules target web server access logs (Apache, Nginx, IIS). Field names for the webserver category vary by pipeline — adjust cs-uri / cs-uri-query to your log mapping (e.g., url.original for ECS, RequestURL for some firewalls).

YAML
---
title: Nexter Blocks Pro Registration Endpoint Access With ACF Parameters
description: Detects HTTP requests to the WordPress AJAX endpoint carrying Nexter Blocks Pro registration ACF parameters (tpgb_acf_key / tpgb_acf), the exploitation vector for CVE-2026-125294. Any unauthenticated request matching this pattern on a patched or removed plugin is high-fidelity; on vulnerable versions it warrants immediate review.
references:
  - https://nvd.nist.gov/vuln/detail/CVE-2026-125294
id: 3f7b2c91-6a4e-4d58-9c21-8e5d0a1b7f42
status: experimental
author: Security Arsenal
date: 2026/04/06
tags:
  - attack.initial_access
  - attack.t1190
logsource:
  category: webserver
detection:
  selection_endpoint:
    cs-uri|contains:
      - 'admin-ajax.php'
  selection_params:
    cs-uri-query|contains:
      - 'tpgb_acf_key'
      - 'tpgb_acf%5B'
      - 'tpgb_acf['
  condition: selection_endpoint and selection_params
falsepositives:
  - Legitimate user registrations on sites actively using the Nexter Blocks registration block — baseline expected volume per host and alert on deviation
level: high
---
title: Unicode Homoglyph in WordPress Registration Parameter (CVE-2026-125294)
description: Detects percent-encoded UTF-8 homoglyph byte sequences (e.g. U+1E87 LATIN SMALL LETTER W WITH DOT ABOVE, U+00E7 C WITH CEDILLA) inside Nexter Blocks ACF parameters — the specific bypass technique for the byte-level denylist in CVE-2026-125294. ASCII-only keys never legitimately require these encodings.
references:
  - https://nvd.nist.gov/vuln/detail/CVE-2026-125294
id: 9d4e1a06-2b83-4f77-a5c0-6c3e9d812f5a
status: experimental
author: Security Arsenal
date: 2026/04/06
tags:
  - attack.initial_access
  - attack.t1190
  - attack.defense_evasion
logsource:
  category: webserver
detection:
  selection_param:
    cs-uri-query|contains:
      - 'tpgb_acf'
  selection_homoglyph:
    cs-uri-query|contains:
      - '%E1%BA%87'
      - '%e1%ba%87'
      - '%C3%A7'
      - '%c3%a7'
      - '%E1%B9%97'
      - '%C4%89'
      - '%E1%B9%A1'
  condition: selection_param and selection_homoglyph
falsepositives:
  - Effectively none — legitimate ACF field keys in WordPress are ASCII slugs; non-ASCII bytes in these parameter names are a strong malicious signal
level: critical

KQL — Microsoft Sentinel / Defender

This query unions common web log ingestion paths (WAF/firewall CEF via CommonSecurityLog, IIS via W3CIISLog, and generic syslog forwarding) and flags both the exploitation endpoint and the homoglyph encodings. Run it retroactively over at least 30 days — if the vulnerability has been present, you want to know whether it was hit before you patched.

KQL — Microsoft Sentinel / Defender
let ExploitParams = dynamic(["tpgb_acf_key", "tpgb_acf%5b", "tpgb_acf["]);
let Homoglyphs = dynamic(["%e1%ba%87", "%c3%a7", "%e1%b9%97", "%c4%89", "%e1%b9%a1"]);
union isfuzzy=true
    (CommonSecurityLog
    | where RequestURL has "admin-ajax.php" and RequestURL has_any (ExploitParams)
    | extend HomoglyphSeen = set_has_element(Homoglyphs, tolower(RequestURL))
    | project TimeGenerated, SourceIP, DestinationHostName, RequestMethod, RequestURL, HomoglyphSeen, Source = "CommonSecurityLog"),
    (W3CIISLog
    | where csUriStem has "admin-ajax.php" and csUriQuery has_any (ExploitParams)
    | extend HomoglyphSeen = set_has_element(Homoglyphs, tolower(csUriQuery))
    | project TimeGenerated, cIP, sSiteName, csMethod, csUriStem, csUriQuery, scStatus, HomoglyphSeen, Source = "W3CIISLog"),
    (Syslog
    | where SyslogMessage has "admin-ajax.php" and SyslogMessage has_any (ExploitParams)
    | extend HomoglyphSeen = set_has_element(Homoglyphs, tolower(SyslogMessage))
    | project TimeGenerated, HostIP, Computer, SyslogMessage, HomoglyphSeen, Source = "Syslog")
| extend AlertSeverity = iff(HomoglyphSeen, "CRITICAL - homoglyph bypass attempt", "HIGH - exploit endpoint touched")
| order by TimeGenerated desc

Follow up any hit by pivoting on the source IP: look for subsequent requests to /wp-login.php, plugin/theme editor endpoints, or uploads of PHP files into /wp-content/uploads/ — the standard post-admin-takeover tradecraft.

Velociraptor VQL — Retroactive Log Hunt on the Web Tier

If your WordPress hosts are enrolled in Velociraptor, this artifact greps the on-disk web server access logs for the exploitation pattern, including the percent-encoded homoglyphs. It is the fastest way to answer the question "were we hit?" across a fleet without waiting on SIEM ingestion gaps.

VQL — Velociraptor
-- CVE-2026-125294: Hunt web access logs for Nexter Blocks Pro ACF parameter abuse
LET Logs = SELECT FullName
FROM glob(globs=[
  '/var/log/apache2/access*.log*',
  '/var/log/nginx/access*.log*',
  '/var/log/httpd/access_log*',
  '/var/log/apache2/other_vhosts_access*.log*'
])

SELECT FullName AS LogFile,
       Line AS MatchingRequest,
       if(condition=Line =~ '%[Ee]1%[Bb][Aa]%87|%[Cc]3%[Aa]7|%[Ee]1%[Bb]9%97',
          then='HOMOGLYPH_BYPASS_ATTEMPT',
          else='ENDPOINT_TOUCHED') AS Severity
FROM foreach(row=Logs,
query={
    SELECT FullName, Line
    FROM parse_lines(filename=FullName, accessor='file')
    WHERE Line =~ 'admin\\-ajax\\.php'
      AND Line =~ 'tpgb_acf'
})

For confirmed hits, collect $MFT, the site's wp-content/uploads/ directory listing, and the WordPress database for triage — specifically the wp_usermeta and wp_users tables.

Immediate Verification and Remediation Script

The following Bash script checks the installed Nexter Blocks Pro version (via WP-CLI where available, falling back to parsing the plugin header), sweeps web logs for exploitation attempts, audits the usermeta table for collation-spoofed capability keys, and lists all administrator accounts for review. Run it on every WordPress host. Requires WP-CLI and database access for the full audit; the log sweep works standalone.

Bash / Shell
#!/usr/bin/env bash
# CVE-2026-125294 - Nexter Blocks Pro privilege escalation verification script
# Run as a user with read access to the WordPress docroot, web logs, and wp-cli.
set -u

WP_ROOT="${1:-/var/www/html}"
PLUGIN_SLUG="nexter-blocks-pro"

echo "=== [1] Plugin version check ==="
if command -v wp >/dev/null 2>&1; then
  wp --path="$WP_ROOT" --allow-root plugin list --format=csv 2>/dev/null | grep -i nexter
else
  find "$WP_ROOT/wp-content/plugins" -maxdepth 2 -iname '*.php' -path '*nexter*' \
    -exec grep -Hm1 'Version:' {} \; 2>/dev/null
fi
echo "[!] Any reported version <= 5.0.10 is VULNERABLE to CVE-2026-125294."

echo
echo "=== [2] Web log sweep for exploitation attempts ==="
grep -rEis --include='access*.log*' 'admin-ajax\.php.*tpgb_acf' \
  /var/log/apache2/ /var/log/nginx/ /var/log/httpd/ 2>/dev/null | tail -n 50
echo "--- Homoglyph-encoded attempts (highest fidelity) ---"
grep -rEis --include='access*.log*' 'tpgb_acf.*(%e1%ba%87|%c3%a7|%e1%b9%97)' \
  /var/log/apache2/ /var/log/nginx/ /var/log/httpd/ 2>/dev/null | tail -n 50

echo
echo "=== [3] Database audit: collation-spoofed capability keys ==="
if command -v wp >/dev/null 2>&1; then
  wp --path="$WP_ROOT" --allow-root db query \
    "SELECT umeta_id, user_id, meta_key, meta_value FROM wp_usermeta \
     WHERE meta_key = 'wp_capabilities' COLLATE utf8mb4_0900_ai_ci \
       AND meta_key <> 'wp_capabilities';" 2>/dev/null
  echo "[!] Any row returned above = confirmed Unicode-spoofed capabilities key. Investigate that user_id NOW."
  echo
echo "=== [4] Administrator account review ==="
  wp --path="$WP_ROOT" --allow-root user list --role=administrator \
    --fields=ID,user_login,user_email,user_registered --format=table 2>/dev/null
  echo "[!] Validate every account above against your expected admin roster, especially recent user_registered dates."
else
  echo "[-] wp-cli not found; run the SQL manually: SELECT umeta_id,user_id,meta_key FROM wp_usermeta WHERE meta_key = 'wp_capabilities' COLLATE utf8mb4_0900_ai_ci AND meta_key <> 'wp_capabilities';"
fi

Remediation and Hardening

  1. Patch immediately. Update Nexter Blocks Pro to a version newer than 5.0.10 (the last confirmed vulnerable release). Pull the update through your normal WordPress update channel or the vendor's customer portal, and verify the version on every site — including staging environments, which are frequently internet-reachable and forgotten. If the vendor has not yet shipped a fixed release for your license channel, deactivate the plugin until one is available; a page-builder convenience feature is not worth unauthenticated remote admin.
  2. If you cannot patch today, apply compensating controls:
    • WAF / reverse proxy rule: Block requests to /wp-admin/admin-ajax.php where the query string or POST body contains tpgb_acf_key or tpgb_acf[ together with any non-ASCII or percent-encoded byte outside the printable ASCII range. At minimum, block the known homoglyph encodings (%e1%ba%87, %c3%a7, and related accented-look-alike ranges). This directly severs the documented exploitation path.
    • Disable front-end registration if the Nexter registration block is not a business requirement — removing the endpoint removes the attack surface.
  3. Hunt before you declare victory. Because this vulnerability leaves a durable artifact (a decorated meta_key in wp_usermeta and a rogue administrator account), run the database audit from the script above on every site that ever ran a vulnerable version. A patch applied after exploitation changes nothing about an admin account created yesterday.
  4. Post-compromise IR steps (if the audit returns hits): treat the site as fully compromised. Take a forensic image or snapshot first, then remove rogue admin accounts and spoofed usermeta rows, force credential resets for all users, rotate WordPress salts/keys in wp-config.php, audit wp-content/uploads and theme/plugin files for web shells and injected code, and review outbound connections from the host for secondary payloads. Follow your standard IR runbook — site takeover frequently escalates to host-level compromise within hours.
  5. Track KEV status and enforce SLA. Monitor the CISA KEV catalog and the NVD entry; a 9.8 unauthenticated RCE-adjacent flaw in a WordPress plugin is a prime KEV candidate, which would impose a formal remediation deadline for federal agencies and a de facto one for everyone else.
  6. Fix the pattern, not just the plugin. If your organization develops or maintains custom WordPress plugins, audit any code that filters user-controlled meta keys, option names, or capability strings with byte-level denylist matching. Normalize input (e.g., to NFKC and strip non-ASCII) before comparison, and prefer allowlists of known-safe keys over denylists of known-bad ones. This Unicode/collation mismatch technique will be reused against other targets.

The Bottom Line

CVE-2026-125294 is a masterclass in why input validation must respect every layer of the stack that will interpret that input. A denylist that was correct in PHP was silently undone by MySQL's collation semantics, and the result is unauthenticated administrator access on a widely deployed WordPress plugin. Patch past 5.0.10 today, sweep your logs and your usermeta tables for the decorated-key artifact, and verify your administrator roster. The detection content above is tuned for high fidelity — the homoglyph encodings in these parameters have essentially no legitimate reason to exist, so if you see them, you are looking at an attack.

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.