Introduction
A support ticket form is meant to be the most public part of a WordPress site, and in the ELEX WordPress HelpDesk & Customer Ticketing System plugin that form became a route from an anonymous visitor to code execution on the server. According to Wordfence, an attacker needs only one anonymous GET to harvest a token and one unauthenticated POST carrying a serialized PHP object in a ticket field, with no account and no victim interaction.
The plugin, which its vendor also markets as WSDesk Free, is an open-source support ticketing system for WordPress and WooCommerce. It converts emails into tickets, lets agents respond through email, and stores tickets and settings with the site operator instead of an external cloud service. It is published by ELEXtensions, a brand introduced by Elula Tech Private Limited in 2018 that specializes in WordPress and WooCommerce plugins and says its broader portfolio serves tens of thousands of businesses. The WordPress plugin directory reports 200+ active installations for this specific plugin, so the footprint is modest, but on every affected site the vulnerable code runs inside the same PHP environment as WordPress itself.
The CNA rates CVE-2026-119077 at CVSS 3.1 9.8 (Critical) and classifies it as CWE-502, Deserialization of Untrusted Data. All versions up to and including 3.3.9 are affected, and 3.4.0 is the patched release. As of November 13, 2026, the reviewed sources do not confirm exploitation in the wild.
Technical information
Root cause: a public nonce in front of unrestricted deserialization
The published root cause combines two failures:
- Missing server-side authentication. The only guard on the ticket submission path is a nonce,
wsdesk_nonce, which the plugin emits on any public page carrying the[wsdesk_support]shortcode. - Deserialization without a class allowlist. The attacker-controlled
ticket_labelfield inside the URL-encodedformparameter ends up being passed to PHP deserialization with no restriction on which classes may be instantiated.
The referenced 3.3.8 source shows how the first failure looks in practice. In eh_crm_new_ticket_post (lines 151 through 156 of the AJAX functions file), the handler checks wsdesk_nonce against the submitted nonce value, copies the POST data, and parses the submitted form string. Separately, the initialization handler localizes an AJAX URL and creates the wsdesk_nonce value for the front end. WordPress's own documentation is explicit that nonces must never be relied on for authentication, authorization or access control. A nonce that any anonymous visitor can read from a public page is a request token and says nothing about who sent the request, which is why the advisory classifies this attack as unauthenticated.
The CNA's vector, CVSS:3.1/AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H, reflects this: network reachable, low complexity, no privileges, no user interaction, unchanged scope, and high impact on confidentiality, integrity and availability.
The vulnerable metadata layer in 3.3.9
The plugin stores ticket and settings metadata in its own tables (wsdesk_ticketsmeta and wsdesk_settingsmeta). Comparing the tagged 3.3.9 copy of includes/class-crm-public-functions.php with 3.4.0 shows that both the write and read paths were unsafe.
On the write side, a value was serialized only if it was an array. Strings were written to the database exactly as received:
if ( is_array( $value ) ) { $data = serialize( $value ); } else { $data = $value; }
On the read side, stored values went through maybe_unserialize() or a raw unserialize(), with nothing limiting which classes could be created:
if ( null !== $key ) { return maybe_unserialize( $data[0]['meta_value'] ); } ... return maybe_unserialize( $retrived );
The same is_serialized( ... ) ? unserialize( ... ) : ... pattern appears across the view and trigger engine, including eh_crm_condition_validate_tickets, eh_crm_view_tickets_group and eh_crm_get_ticketmeta_value_count. Two report functions called unserialize( $tickets['meta_value'] ) with no check at all.
Taken together, this is a stored deserialization primitive. A string that happens to be a serialized PHP object is accepted as an ordinary string, saved unchanged, and reconstructed as a live object when the plugin later reads that meta value.
From object injection to code execution
OWASP describes PHP object injection as attacker-supplied serialized data reaching unserialize() and causing objects to be reconstructed. Exploitation generally depends on usable magic methods such as __wakeup or __destruct, or a property-oriented programming (POP) chain, built from classes that are already declared or available through autoloading.
The advisory references include the copy of Guzzle's src/Cookie/FileCookieJar.php that is bundled inside the plugin's vendor directory. FileCookieJar is publicly known for writing its cookie data to a file when the object is destroyed, which makes it a plausible file-write gadget. The CNA and Wordfence state that the chain reaches code execution, but the published material does not document the complete gadget sequence or the exact role of FileCookieJar. What the sources do establish is that anonymous ticket input crosses into server code execution.
Attack flow
Based on the advisory and the patch analysis, the sequence is:
- The attacker identifies any public page on the target site that carries the
[wsdesk_support]shortcode. - A single anonymous GET to that page returns the localized AJAX URL and the
wsdesk_noncevalue. - The attacker sends a single unauthenticated POST to the plugin's ticket submission handler, supplying the harvested nonce and a
formparameter whoseticket_labelfield contains a serialized PHP object. - The nonce check passes, the
formstring is parsed, and becauseticket_labelis a string, the 3.3.9 write path stores it without modification. - When the plugin deserializes that meta value through
maybe_unserialize()orunserialize(), PHP instantiates the attacker's object graph, and magic methods in available classes execute. Wordfence states that this single POST completes the attack and results in code execution on the server.
Patch information
The fixed release is ELEX WordPress HelpDesk & Customer Ticketing System 3.4.0. Wordfence lists all versions through 3.3.9 as affected and identifies SVN changeset 3797458 (trunk/includes/class-crm-public-functions.php), committed by elextensions with the message updated to 3.4.0, as the fix. The 3.4.0 readme says only "Security fix: Resolved a vulnerability issue.", so the code itself is the detailed record. The analysis below compares the tagged 3.3.9 and 3.4.0 copies of includes/class-crm-public-functions.php.
The patch adds four helper functions at the top of the file and routes every serialize and unserialize call in that file through them.
1. eh_crm_has_object_or_serialized_object() is a recursive detector. It returns true for real objects, for strings containing a NUL byte (which appears in serialized private and protected properties), and for strings matching the serialized object token O:<n>:" or the custom serialized class token C:<n>:".
2. eh_crm_safe_unserialize() replaces every read path with three layers of checking:
if ( eh_crm_has_object_or_serialized_object( $data ) ) { return false; } ... $unserialized = @unserialize( trim( $data ), array( 'allowed_classes' => false ) ); ... if ( is_object( $unserialized ) || ( is_array( $unserialized ) && eh_crm_has_incomplete_class( $unserialized ) ) ) { return false; }
- Any string that looks like it contains an object is refused before it reaches
unserialize(). allowed_classes => falseis the main control. Even if a payload evades the pattern check, PHP will not instantiate any real class; the data becomes an inert__PHP_Incomplete_Class, so no__wakeupor__destructgadget code runs.eh_crm_has_incomplete_class()discards results that still contain an object, so callers never receive even the inert placeholder.
3. eh_crm_safe_serialize() guards the write side. It returns false for objects and for any value, including strings and nested arrays, that contains serialized object markers. eh_crm_insert_ticketmeta, eh_crm_update_ticketmeta, eh_crm_insert_settingsmeta and eh_crm_update_settingsmeta now refuse to write in that case:
$data = eh_crm_safe_serialize( $value ); if ( false === $data && false !== $value && '0' !== $value && 0 !== $value && '' !== $value ) { return false; }
4. Every sink in the file was replaced. eh_crm_get_ticketmeta, eh_crm_get_ticketmeta_archive, eh_crm_get_settingsmeta, eh_crm_validate_attachment_paths, the value count helpers, the view and trigger condition engine, the grouping logic and both donut report functions now call eh_crm_safe_unserialize(). The extra maybe_unserialize( $retrived ) applied to the whole returned array was removed, and the report code gained is_array() guards before in_array() and foreach.
Why this works. The fix covers both ends of the stored injection chain. A malicious serialized object is refused when written, and if one was already stored before the update, reading it can no longer create a real class. The allowed_classes => false read path is the primary barrier, with the pattern detector and write filter layered on top.
What remains unverified. Wordfence also names the missing authentication on the AJAX path as a cause. The changes examined here sit in the shared serialization layer. We did not compare the AJAX handler files, so we cannot confirm whether 3.4.0 also added an authentication or capability check there. For maintainers, the PHP manual advises against passing untrusted input to unserialize() regardless of the allowed_classes setting and recommends JSON (json_encode() and json_decode()) for data exchanged with users, a recommendation OWASP shares. WordPress recommends protecting privileged operations with current_user_can() and assuming nonces can be compromised.
The WordPress directory snapshot reviewed in the briefing still listed 3.3.9, while Wordfence and the repository identify 3.4.0. The directory's displayed version should not be taken as evidence that 3.3.9 is safe.
Detection methods
We found no public Sigma, YARA, Snort/Suricata or Nuclei signature for CVE-2026-119077, and no campaign indicators (IPs, hashes or webshell names) have been published. Two sources record no confirmed exploitation and no KEV listing as of November 13, 2026, and StackFlag labels the issue not known to be exploited. The Wordfence advisory describes the attack chain clearly enough to build reliable in-house detections at four levels.
1. Exposure: find vulnerable installs and the pages that expose the bug
- Check the plugin version. The slug is
elex-helpdesk-customer-support-ticket-system. Anything at 3.3.9 or lower is vulnerable; 3.4.0 is the first fixed version. Read the installed version from the WordPress plugins screen, the WordPress command-line interface, or your asset or SCA inventory. - Use vulnerability feeds. Wordfence Intelligence has a record for this CVE, and Wordfence states its vulnerability API and webhooks are free, so the record can feed scanners or a SIEM. Sites running the Wordfence plugin are notified when an installed plugin matches a database entry. NextGuard and AcidPeak also track the CVE.
- Inventory pages carrying
[wsdesk_support]. The attack only works through a page containing the shortcode, because that page hands every visitor thewsdesk_noncetoken. Knowing these URLs tells you which requests to watch.
2. Network and logs: a GET followed by a POST
Correlate the same source IP fetching a support form page and then, within a few seconds, sending a POST that includes wsdesk_nonce and form. Weight the event higher if no WordPress login cookie is present, and higher still if the client looks scripted: no static asset loads, a generic user agent, or machine-perfect timing. Legitimate visitors typically load CSS, JavaScript and images and take time to write a ticket. On its own this is a weak signal, since genuine submissions look similar. Use it to select requests for payload inspection.
3. Payload: serialized PHP objects in ticket_label
This is the most reliable check.
- Decode more than once.
formis itself a URL-encoded form string, so the serialized object inside the POST body is usually percent encoded twice. A rule matching only the raw body will miss it. Decode at least two passes, split the decodedformstring into fields, and inspectticket_label. - Match object syntax. A real ticket label is a short plain-text string. Any serialized object marker in that value, meaning PHP's
O:form followed by a length and a quoted class name, or a custom serializedC:object, is a high-confidence indicator with very few expected false positives. - Watch for Guzzle class names. Because the advisory references the bundled Guzzle
FileCookieJarclass, flagGuzzleHttpclass names, andFileCookieJarin particular, in decoded request bodies. Its use as the gadget is an inference from the references, not a statement in the advisory. - Capture request bodies. Standard Apache and Nginx access logs do not record POST bodies. Use a WAF (ModSecurity, Coraza, a cloud WAF or the Wordfence firewall), a body-capturing reverse proxy, or PHP-level request logging on sites still running a vulnerable version.
4. Host-side signs of a successful attack
- New or modified PHP files in web-writable locations such as
wp-content/uploads, the plugin directory or the web root, with creation times that line up with a suspicious POST. File integrity monitoring or scheduled malware scans will catch these. - The PHP or web server process spawning shells or system tools. Alert through EDR or auditd when the web server user starts processes it normally would not.
- WordPress-level changes shortly after a suspicious submission, such as new administrator accounts or new or edited plugins.
These host checks are generic. Their value comes from correlating their timing with the request patterns above.
Affected systems and versions
- Product: ELEX WordPress HelpDesk & Customer Ticketing System (WordPress plugin slug
elex-helpdesk-customer-support-ticket-system), vendor elextensions. - Affected: all versions up to and including 3.3.9.
- Fixed: 3.4.0 or a newer patched release.
- Exposing configuration: any site running an affected version where a publicly reachable page carries the
[wsdesk_support]shortcode, since that page emits thewsdesk_noncevalue the attack requires. - Note on 3.3.9: its changelog fixes unauthorized file deletion in factory reset and adds metadata validation, but 3.3.9 is still affected by this object injection flaw.
The issue is specific to this plugin and does not affect WordPress core. Wordfence and the CNA credit Osman Hussein of Onvio B.V. with the discovery. The CNA record was published on November 13, 2026 at 09:35 UTC and Wordfence dates its advisory November 12, 2026. At the time of review, the NVD page returned CVE ID Not Found.
Vendor security history
Wordfence lists several earlier vulnerabilities in the same plugin, each marked as patched:
- CVE-2026-114630: unauthenticated arbitrary file deletion via
ticket_attachment_path, versions through 3.3.8, CVSS 9.1. - CVE-2025-9343: unauthenticated stored cross-site scripting, versions through 3.3.4, CVSS 7.2.
- CVE-2024-12171: missing authorization enabling Subscriber-or-higher privilege escalation, versions through 3.2.6, CVSS 8.8.
These records show several distinct failure classes in one plugin, two of them reachable without authentication. They do not establish that other ELEXtensions products share the same weaknesses, and they do not quantify vendor response times. The 3.3.9 release fixed one security issue and was still affected by this one, so a release that addresses one security issue is not evidence that it addresses issues disclosed later.
References
- NVD entry for CVE-2026-119077
- CVE.org record for CVE-2026-119077
- CVE Services JSON record (CNA)
- Wordfence advisory: Unauthenticated PHP Object Injection to Remote Code Execution via form Parameter
- Wordfence Intelligence record (detection source)
- Wordfence vulnerability history for the plugin
- Changeset 3797458 (fix for 3.4.0)
- Plugin SVN: 3.3.9 public functions file
- Plugin SVN: 3.4.0 public functions file
- Plugin SVN: 3.4.0 readme
- 3.3.8 source: ticket submission handler, line 156
- 3.3.8 source: AJAX functions two, line 265
- 3.3.8 source: AJAX functions, line 946
- 3.3.8 source: init handler nonce localization, line 529
- 3.3.8 source: public functions, line 627
- 3.3.8 source: public functions, line 822
- 3.3.8 source: bundled Guzzle FileCookieJar, line 45
- WordPress.org plugin directory listing
- ELEXtensions: About Us
- ELEXtensions: WSDesk Free product page
- ELEXtensions: WSDesk changelog
- StackFlag assessment
- AcidPeak threat entry
- NextGuard vulnerability entry
- WordPress Developer Resources: Nonces
- OWASP: PHP Object Injection
- PHP Manual: unserialize
- MITRE CWE-502: Deserialization of Untrusted Data



