← Back to Feed CACHED · 2026-10-16 08:04:43 · CACHE_KEY CVE-2026-94169
CVE-2026-94169 · CWE-94 · Disclosed 2026-10-16

The Grid WordPress Plugin Unauthenticated Code Injection / RCE

ASSESSED — NOISGATE
Vendor
—
—
—
Reassessed
—
—
—
Verdict: —
Do you agree?
01 · The Real Story

Someone left the master key under the doormat, but the doormat is at a house almost nobody lives in

CVE-2026-94169 is an unauthenticated code injection vulnerability in The Grid, a premium WordPress grid-layout plugin by Theme-one sold exclusively through CodeCanyon/Envato. All versions through 2.8.1 are affected; the flaw allows a remote, unauthenticated attacker to inject and execute arbitrary PHP code via a vulnerable AJAX handler, yielding full remote code execution (RCE) under the web server's process context. The fix shipped in version 2.8.2 on September 21, 2026 — roughly 25 days before public CVE disclosure on October 16, 2026. Discovered by Rafie Muhammad through the Patchstack Bug Bounty Program.

The vendor and Patchstack scored this a perfect CVSS 10.0 — and *for the bug itself*, that's defensible: network-reachable, zero-click, zero-auth, scope-changed, full CIA impact. In isolation, this is as bad as an RCE gets. However, the real-world blast radius is microscopic: The Grid has ~13,633 lifetime CodeCanyon sales across 11 years, translating to perhaps 4,000–8,000 active installations worldwide. It's a premium purchase, not a freely-distributed wordpress.org plugin. For an enterprise managing 10,000 hosts, the probability of finding this plugin in your fleet is near zero unless you run a WordPress hosting or digital-agency operation. The CVSS 10.0 tells you nothing about whether this matters *to you* — noisgate's reassessment factors in installed-base reality and lands at HIGH (8.0): genuinely dangerous if present, but not a fleet-wide fire drill.

"Unauth RCE in a premium WP plugin — critical for the few who have it, irrelevant to most fleets."
02 · The Attack Path

4 steps from start to impact.

STEP 01

Fingerprint The Grid plugin

The attacker identifies a WordPress site running The Grid by probing for characteristic asset paths such as /wp-content/plugins/the-grid/ or recognizing The Grid's front-end CSS/JS fingerprints in page source. WordPress plugins routinely expose their directory structure and version via readme.txt or inline comments. Automated scanners like WPScan or Nuclei can enumerate this at scale.
Conditions required:
  • Target runs WordPress with The Grid plugin ≤ 2.8.1
  • Plugin assets are web-accessible (default WordPress behavior)
Where this breaks in practice:
  • The Grid is a premium CodeCanyon plugin with ~13,633 total lifetime sales — extremely rare in the wild compared to plugins with millions of installs
  • No wordpress.org listing means no centralized directory exposure or auto-update push notifications
Detection/coverage: WPScan, Nuclei, or custom wp-content/plugins/the-grid/readme.txt HTTP probe
STEP 02

Craft unauthenticated AJAX code-injection payload

The attacker sends a specially crafted HTTP POST request to the WordPress admin-ajax.php endpoint, targeting a vulnerable AJAX action registered by The Grid. The action handler improperly constructs PHP code by concatenating attacker-controlled input and passes it through an evaluation path (likely eval(), preg_replace with /e, or dynamic call_user_func). No authentication token or nonce is required because the handler is registered via wp_ajax_nopriv_*.
Conditions required:
  • Vulnerable AJAX action is registered and reachable via admin-ajax.php
  • No WAF or input-validation layer blocks the payload
Where this breaks in practice:
  • A well-configured WAF (ModSecurity with CRS, Cloudflare WAF, Wordfence) would likely flag PHP code-injection patterns in POST parameters
  • Some managed WordPress hosts (WP Engine, Kinsta, Pantheon) restrict or filter admin-ajax.php behavior
Detection/coverage: WAF logs showing PHP injection patterns in POST body to admin-ajax.php; Wordfence firewall rules may catch generic code injection
STEP 03

Achieve RCE as web server process

Successful injection executes arbitrary PHP in the context of the web server user (typically www-data or apache). The attacker can now read wp-config.php (database credentials, auth salts, secret keys), write webshells, exfiltrate data, or pivot. The CVSS scope-change (S:C) reflects that the attacker can break out of the WordPress application boundary into the underlying OS.
Conditions required:
  • PHP execution succeeds (not disabled by disable_functions or open_basedir)
  • Web server process has typical file-system access
Where this breaks in practice:
  • Hardened PHP configurations (disable_functions=exec,system,passthru,shell_exec) limit OS-level command execution but not PHP-level data access
  • Container-isolated WordPress deployments (Docker/K8s) limit lateral movement from the web server process
Detection/coverage: File-integrity monitoring (OSSEC, Wazoo, Tripwire) detecting new .php files in plugin directories; EDR detecting child processes spawned by PHP-FPM/Apache
STEP 04

Post-exploitation: data exfiltration or lateral movement

With wp-config.php credentials, the attacker connects to the MySQL database and dumps user tables, WooCommerce order data, or customer PII. If the database server is shared or the web server has network access to internal resources, the attacker may pivot. On WooCommerce-enabled sites, payment metadata and customer records are primary targets.
Conditions required:
  • Database is network-accessible from the web server (standard)
  • Valuable data exists in the WordPress database
Where this breaks in practice:
  • Most WordPress sites behind this plugin are small business / portfolio sites with limited high-value data
  • Network segmentation between DMZ web tier and internal network limits lateral movement
  • Payment card data is typically handled by third-party gateways (Stripe, PayPal) not stored in WP database
Detection/coverage: Database audit logging detecting unusual SELECT/DUMP patterns; network monitoring detecting outbound data exfiltration from web server
03 · Compensating Control

1
HIGH 8.0→IGNORE 0.0
SEVERITY REDUCED
Identify and update all The Grid installations to 2.8.2 immediately — The patch has been available on CodeCanyon since September 21, 2026. This is the definitive fix. Download v2.8.2 from your Envato account and deploy via wp-admin or WP-CLI (wp plugin install the-grid.zip --force). Under the noisgate mitigation SLA for HIGH, deploy within 30 days — but given the unauth RCE nature, prioritize this within days if the plugin is present.
2
HIGH 8.0→IGNORE 0.0
SEVERITY REDUCED
Deactivate The Grid plugin if update is not immediately available — Run wp plugin deactivate the-grid on affected sites. This removes the vulnerable AJAX handler registration entirely, eliminating the attack surface. Zero functionality impact on the rest of the WordPress site beyond grid layouts disappearing. Do this as interim mitigation within hours if you cannot update immediately.
3
HIGH 8.0→MEDIUM 5.5
SEVERITY REDUCED
Deploy WAF rules blocking PHP code injection in admin-ajax.php POST parameters — Configure ModSecurity CRS (rule 933xxx series), Cloudflare WAF, or Wordfence firewall to inspect POST bodies to admin-ajax.php for PHP injection patterns (eval(, system(, base64_decode(, <?php). This adds defense-in-depth but is bypassable with encoding. Deploy within the 30-day noisgate mitigation SLA for HIGH.
4
HIGH 8.0→HIGH 7.0
Harden PHP execution environment — Set disable_functions=exec,system,passthru,shell_exec,popen,proc_open and open_basedir in php.ini to restrict the blast radius of any code injection. This does not prevent PHP-level exploitation (database access, file reads) but blocks OS command execution. Apply as standing hardening policy.
What doesn't work
  • WordPress nonce verification — The vulnerable handler is registered on wp_ajax_nopriv_*, meaning it explicitly bypasses WordPress's authentication and nonce system. Adding nonces elsewhere does not help.
  • Updating WordPress core — This is a plugin-level vulnerability; WordPress core updates do not patch third-party plugin code. WP 6.7.x is irrelevant to this CVE.
  • IP allowlisting on wp-admin — The vulnerable endpoint is admin-ajax.php, which must remain publicly accessible for front-end AJAX functionality on most WordPress sites. Blocking it breaks legitimate site features.
  • Sucuri or generic malware scanning — Post-exploitation scanners detect webshells *after* compromise, not the initial code injection. They're reactive, not preventive for this attack vector.
04 · Intelligence Metadata

The supporting signals.

In-the-Wild ExploitationNone observed. Not listed in CISA KEV. No GreyNoise tags or Shadowserver scanning reports for this CVE as of 2026-10-16. The wp2shell WordPress campaign (CVE-2026-63030) is active but targets WordPress core, not this plugin.
Proof-of-ConceptNo public PoC found. Checked pocindex.io, GitHub (CVE-2026-94169), ExploitDB, SecureWithUmer/CVE-2026-PoCs, and XZ1r0/cve-2026-poc-collection — no matches. Patchstack typically embargoes exploit details. Given the unauth RCE nature, a weaponized PoC is likely straightforward to develop by diffing 2.8.1 → 2.8.2.
EPSS ScoreNot yet available. CVE published 2026-10-16 (today); FIRST EPSS API returns no data yet. Expect scoring within 1–3 days. For a WordPress unauth RCE with low complexity, historical EPSS analogs suggest 0.15–0.40 (70th–90th percentile) once scored.
CISA KEV StatusNot listed. No known federal agency exploitation or binding operational directive.
CVSS VectorCVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:C/C:H/I:H/A:H — Perfect 10.0. Network-reachable, no auth, no interaction, scope change, full CIA. The vector is technically accurate for the bug class.
Affected VersionsThe Grid ≤ 2.8.1 (all versions). Vulnerable range: >=0 <2.8.2. Plugin is premium (CodeCanyon), no distro backports apply.
Fixed Version2.8.2 — released 2026-09-21 on CodeCanyon. Patch has been available for 25 days before CVE publication.
Installed Base / Exposure~13,633 lifetime CodeCanyon sales over 11 years. Estimated 4,000–8,000 active installs worldwide. Premium-only distribution (not on wordpress.org). No Shodan/Censys/FOFA fingerprint data specific to this plugin. Censys observes ~62.8M WordPress instances globally but cannot enumerate premium plugin installs.
Disclosure TimelineCVE reserved 2026-09-21 · Patch (v2.8.2) released 2026-09-21 · CVE published 2026-10-16. Silent patch → delayed disclosure pattern, consistent with Patchstack coordinated disclosure.
Researcher / OrgRafie Muhammad via Patchstack Bug Bounty Program. Patchstack is the CNA (CVE assigning authority). Rafie Muhammad is a prolific WordPress vulnerability researcher with hundreds of credited findings.

Sources.

  1. Strix.ai — CVE-2026-94169 Advisory
  2. Offseq Radar — CVE-2026-94169 Technical Details
  3. ThreatInt — CVE-2026-94169
  4. CodeCanyon — The Grid Plugin by Theme-one
  5. OpenCVE — Theme-one The Grid Vulnerabilities
  6. Patchstack — The Grid Broken Access Control (prior CVE)
  7. GitHub Advisory — CVE-2026-28191 (The Grid Privilege Escalation)
  8. PoC Index — CVE Search
05 · The Call

Final Verdict
↓ DOWNGRADED to HIGH (8.0/10)

Why this verdict

  • Unauth RCE is real, but the audience is tiny. The Grid has ~13,633 lifetime sales — orders of magnitude smaller than mass-market WordPress plugins (Elementor: 15M+, WooCommerce: 7M+, Yoast: 13M+). In a 10K-host enterprise fleet, the expected number of hosts running this specific premium plugin rounds to zero unless you operate a WordPress agency or hosting platform.
  • Patch predates disclosure by 25 days. Version 2.8.2 shipped on September 21, 2026. Any site with auto-update (or an attentive admin who noticed the CodeCanyon update notification) is already patched. The silent-patch-then-disclose model means the exploitation window for informed attackers opened today, not a month ago.
  • No exploitation evidence compounds the install-base argument. Zero KEV listing, zero GreyNoise/Shadowserver observations, zero public PoCs. WordPress plugin RCEs with tiny install bases historically attract limited attacker investment — the ROI of scanning millions of WordPress sites for a plugin installed on ~0.01% of them is poor compared to targeting WP core or Elementor.
  • Premium distribution adds friction to mass exploitation. Unlike freely downloadable plugins, The Grid requires a CodeCanyon purchase. Attackers cannot trivially lab-test or diff the plugin without buying it (or pirating it, which is common but still a friction layer). This slows PoC development compared to open-source plugins.
  • Role multiplier: Web application tier, not infrastructure. The Grid is a UI presentation plugin. WordPress servers running it occupy the web/DMZ tier, not identity, hypervisor, backup, CI/CD, or network-edge roles. RCE yields the www-data process — damaging to *that site* but not fleet-scale unless the web server has unusual lateral-movement paths. WooCommerce integration means *some* sites hold customer PII/order data, which bumps impact above MEDIUM, but the canonical deployment is a small-business portfolio site. No high-value-role floor applies.

Why not higher?

CRITICAL would be warranted if the install base were large enough to create fleet-wide exposure or if active exploitation were observed. Neither condition holds: ~13K lifetime sales across 11 years translates to a vanishingly small fraction of the WordPress ecosystem, the patch has been available for 25 days, and there is zero evidence of in-the-wild exploitation or public PoC availability. The component is also not a canonically high-value-role target (not an IdP, hypervisor, CA, EDR agent, or network edge appliance).

Why not lower?

Despite the microscopic install base, this is still unauthenticated RCE with zero attack-chain friction for anyone who *does* have the plugin. There are no authentication barriers, no user interaction requirements, and no complex preconditions — just an HTTP POST to a public endpoint. WordPress sites are internet-facing by default. A PoC is trivially derivable by diffing two PHP releases. Any defender who discovers this plugin in their environment faces an immediate, exploitable exposure with full server compromise potential. MEDIUM would understate the risk for the affected population.

06 · Verification

Crowdsourced verification payload.

Run this script on any Linux/macOS host that has curl and network access to the target WordPress site. No special privileges required. Usage: bash check_the_grid.sh https://example.com — it probes the target site for The Grid plugin presence and version.

noisgate-verify.sh
BASHREAD-ONLYSAFE
#!/usr/bin/env bash
# check_the_grid.sh — CVE-2026-94169 checker for The Grid WordPress plugin
# Usage: bash check_the_grid.sh <wordpress_site_url>
# Exit codes: 0 = VULNERABLE, 1 = PATCHED, 2 = UNKNOWN (plugin not detected)

set -euo pipefail

if [ $# -lt 1 ]; then
  echo "Usage: $0 <wordpress_site_url>"
  echo "Example: $0 https://example.com"
  exit 2
fi

TARGET="${1%/}"
PLUGIN_PATH="/wp-content/plugins/the-grid"
README_URL="${TARGET}${PLUGIN_PATH}/readme.txt"
STYLE_URL="${TARGET}${PLUGIN_PATH}/frontend/css/the-grid.css"
FIXED_VERSION="2.8.2"

echo "[*] Checking for The Grid plugin at: ${TARGET}"
echo ""

# Try readme.txt first (most plugins expose this)
HTTP_CODE=$(curl -s -o /tmp/tg_readme.txt -w "%{http_code}" -L --max-time 10 "${README_URL}" 2>/dev/null || echo "000")

if [ "$HTTP_CODE" = "200" ]; then
  # Extract stable tag / version from readme.txt
  VERSION=$(grep -i '^Stable tag:' /tmp/tg_readme.txt 2>/dev/null | head -1 | sed 's/[Ss]table [Tt]ag:[[:space:]]*//' | tr -d '[:space:]')
  if [ -n "$VERSION" ]; then
    echo "[+] The Grid plugin DETECTED — version: ${VERSION}"
    # Compare versions
    if printf '%s\n' "$FIXED_VERSION" "$VERSION" | sort -V | head -1 | grep -q "^${FIXED_VERSION}$"; then
      # FIXED_VERSION sorts first or equal, meaning VERSION >= FIXED_VERSION
      if [ "$VERSION" = "$FIXED_VERSION" ] || [ "$(printf '%s\n' "$FIXED_VERSION" "$VERSION" | sort -V | tail -1)" = "$VERSION" ]; then
        echo "[PATCHED] Version ${VERSION} >= ${FIXED_VERSION}. CVE-2026-94169 is fixed."
        rm -f /tmp/tg_readme.txt
        exit 1
      fi
    fi
    echo "[VULNERABLE] Version ${VERSION} < ${FIXED_VERSION}. CVE-2026-94169 applies!"
    echo "    -> Update to The Grid >= 2.8.2 immediately."
    rm -f /tmp/tg_readme.txt
    exit 0
  fi
fi

# Fallback: check if plugin directory is accessible
DIR_CODE=$(curl -s -o /dev/null -w "%{http_code}" -L --max-time 10 "${TARGET}${PLUGIN_PATH}/" 2>/dev/null || echo "000")
CSS_CODE=$(curl -s -o /dev/null -w "%{http_code}" -L --max-time 10 "${STYLE_URL}" 2>/dev/null || echo "000")

if [ "$DIR_CODE" = "200" ] || [ "$DIR_CODE" = "403" ] || [ "$CSS_CODE" = "200" ]; then
  echo "[!] The Grid plugin appears to be INSTALLED (directory/assets detected)"
  echo "    but version could not be determined from readme.txt."
  echo "[UNKNOWN] Manually verify: wp plugin list --path=/path/to/wp | grep the-grid"
  rm -f /tmp/tg_readme.txt
  exit 2
fi

echo "[-] The Grid plugin NOT DETECTED on ${TARGET}"
echo "[UNKNOWN] Plugin does not appear to be installed."
rm -f /tmp/tg_readme.txt
exit 2