Attack ChainAIDerived
Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain
-
AccessFind form with List post-custom-field + content template
-
DeliverySubmit crafted serialized PHP object in row
-
ExploitReach unrestricted maybe_unserialize()
-
ExecutionInject PHP object into post meta
-
PersistTrigger WP_Theme::__toString via _wp_page_template
-
ImpactExecute code through PEAR chain
Vulnerability Assessment
| Weakness |
CWE
OWASP Top 10:2025
A08:2025 - Software or Data Integrity Failures
ASVS 5.0
V1 - Encoding and Sanitization Safe deserialization, type allowlists
MITRE ATT&CK
2 techniques across 2 tactics: Execution, Initial Access The technique list with ATT&CK links and the kill-chain view is part of the Basic plan and up. |
| Exploitation Conditions | Exploitation requires the target site to have a Gravity Forms form containing a Post Custom Field whose input type is List with a content template enabled, so that the submitted row value reaches the unrestricted maybe_unserialize() verbatim - this is a non-default form configuration, not present on a stock install. Object injection by itself produces no impact unless a PHP Object Injection gadget chain exists via an additional plugin or theme. The self-contained remote code execution path additionally requires the custom field to be mapped to the protected _wp_page_template meta key AND the host to have a readable PEAR installation AND register_argc_argv enabled. Limiting factors: no authentication or user interaction is needed to reach the injection, but the field configuration and, for RCE, the host environment conditions substantially narrow the realistically exploitable population. |
| Impact | The input CVSS of 9.8 (AV:N/AC:L/PR:N/UI:N, C/I/A:H) frames this as a worst-case unauthenticated remote code execution, and the vuln.today Decision label is act_now with the report sourced from Wordfence, so this should be treated as a priority. However, the signals must be weighed against the mechanism the evidence actually describes: object injection alone has no impact because no PHP Object Injection gadget chain is present in the plugin itself, and full RCE is contingent on either a gadget chain supplied by another plugin/theme or a specific chain (custom field mapped to _wp_page_template, plus a readable PEAR install and register_argc_argv enabled). These are conditions beyond the attacker's control, which argues the realistic complexity is higher than the AC:L in the supplied vector. No KEV status, EPSS probability, or confirmed working exploit is present in the input, so exploitation is not confirmed in the wild; the references are a Wordfence advisory and vendor docs, not a verified PoC. Net: a genuinely serious, unauthenticated-reachable flaw on sites whose forms use the affected configuration, but the headline 9.8 assumes the worst-case RCE chain that depends on non-default form configuration and host environment, so blanket risk across all installs is lower than the score implies. The act_now label still warrants prompt patching. |
| Exploit ScenarioDerived | An unauthenticated attacker submits a Gravity Forms form that writes to a Post Custom Field of List input type with a content template enabled, embedding a serialized PHP object in a submitted row; GFFormsModel::create_post() passes it to WordPress' unrestricted maybe_unserialize(), instantiating the object into post meta. If the field is mapped to the protected _wp_page_template meta key on a host with a readable PEAR install and register_argc_argv enabled, WordPress' own WP_Theme::__toString()/validate_file() chain resolves an attacker-controlled path and yields remote code execution. No confirmed public exploit is identified in the provided data. |
Get an e-mail when this CVE is exploited, patched or re-scored. Free account.
Alert meAnalysisAIv1 – Oct 30, 2026
Unauthenticated PHP object injection in the Gravity Forms WordPress plugin, affecting every version up to and including 3.1.2, lets a remote attacker push a serialized payload into post meta through a Post Custom Field configured with the List input type. The flaw exists because GFFormsModel::create_post() hands the submitted row value to WordPress' global maybe_unserialize() instead of the plugin's own hardened GFCommon::maybe_unserialize() introduced in 3.1.1; the impact of the resulting object injection depends on a gadget chain supplied by another plugin or theme, and a self-contained remote code execution path is described when the field is mapped to _wp_page_template on hosts with a readable PEAR install and register_argc_argv enabled. No public exploit code was identified at time of analysis, and the vulnerability is not in CISA KEV; the assessor's own vector is AC:H rather than the reported AC:L, because exploitation requires a non-default form configuration (a List-type Post Custom Field with a content template) plus, for RCE, specific host conditions. The vuln.today decision label is act_now and the finding is reported by Wordfence, so it should still be triaged as a priority despite the narrowing prerequisites.
RemediationAI
No vendor-released patch is identified in the available data, so the actionable step is to remove the exposure: audit every Gravity Forms form for Post Custom Field entries whose input type is List and which have a content template enabled, and either delete those fields, switch them to a non-List input type, or disable the content template. The trade-off is that any site currently collecting list-style post data through such a field loses that functionality until a fixed release ships. Pay particular attention to any such field mapped to the protected _wp_page_template meta key, since removing that mapping eliminates the self-contained WordPress-native RCE path regardless of the host's PEAR installation or register_argc_argv setting, at the cost of no longer driving page template selection from the form. Because the injection is reached without authentication, also consider restricting who can submit the affected forms until a fix is available, though this reduces legitimate public form submissions. Monitor https://docs.gravityforms.com/ and the Wordfence advisory at https://www.wordfence.com/threat-intel/vulnerabilities/id/ec1fba15-81e5-42e3-9154-1978c3f81b26?source=cve for the release containing the fix, and inventory installed plugins and themes for known PHP Object Injection gadget chains, since their presence converts this object injection into a practical exploitation path. Note that Gravity Forms 3.1.1's GFCommon::maybe_unserialize() hardening does not remediate this issue on its own, as the vulnerable create_post() call site still uses the global function through 3.1.2.
Affected VersionsENISA
Affected Packages
Source: OSV (Open Source Vulnerabilities)
Affects your stack
Affects 1 package in euvd
Checking this CVE against your own stacks and servers is part of the Basic plan and up.
Technical ContextAI · show details
The root cause is CWE-502, deserialization of untrusted data, in a WordPress plugin context. Gravity Forms' GFFormsModel::create_post() processes submitted post custom field values and, for a field using the List input type with a content template enabled, passes the submitted row verbatim into WordPress' unrestricted global maybe_unserialize(). Version 3.1.1 added the plugin's own GFCommon::maybe_unserialize() wrapper, which uses allowed_classes => false specifically to block object instantiation, but the create_post() call site was not migrated to it, so the hardened path is bypassed in 3.1.2 and earlier. Object injection alone yields no impact without a PHP Object Injection gadget chain; the plugin ships none, so impact materializes only when a gadget chain is available from another installed plugin or theme. The description also details a chain that requires no third-party gadget: if the custom field is mapped to the protected _wp_page_template meta key, WordPress' own validate_file() accepts non-scalar values, WP_Theme::__toString() then resolves an attacker-controlled path, and on hosts with a readable PEAR installation and register_argc_argv enabled this produces remote code execution. The reported vector is AV:N/AC:L/PR:N/UI:N with C/I/A:H for a 9.8 score; the independent assessment keeps AV:N/PR:N/UI:N and the same impact ratings but raises AC to H, reflecting the non-default form configuration and, for the RCE path, the host environment prerequisites.
Know when Gravity Forms gets its next vulnerability
- Watch products and get an email when something new is published
- Check this CVE against your own stack and servers
- Exploit and PoC references, threat intelligence from 22 sources
No credit card · 7-day full trial
Severity by source
AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H
Unauthenticated and remote (PR:N, UI:N, AV:N), but AC:H because exploitation depends on a specific non-default List field configuration and, for RCE, on host conditions (PEAR, register_argc_argv) beyond the attacker's control.
Primary rating from Vendor (Wordfence).
CVSS VectorVendor: Wordfence
DescriptionCVE.org
The Gravity Forms plugin for WordPress is vulnerable to PHP Object Injection in all versions up to, and including, 3.1.2 via a Post Custom Field whose input type is List. This is due to GFFormsModel::create_post() passing the submitted value to WordPress' unrestricted global maybe_unserialize() rather than the plugin's own hardened GFCommon::maybe_unserialize(), which was added in 3.1.1 and passes allowed_classes => false precisely to prevent object instantiation. Where the field has a content template enabled, the submitted row reaches that call verbatim. This makes it possible for unauthenticated attackers to inject a PHP object into post meta. No PHP Object Injection gadget chain is present in the plugin itself; however, if a gadget chain is present via an additional plugin or theme, it could allow the attacker to perform actions such as remote code execution. Where the custom field is mapped to the protected _wp_page_template meta key, WordPress itself supplies the chain: validate_file() accepts non-scalars, WP_Theme::__toString() then resolves an attacker-controlled path, and on hosts with a readable PEAR install and register_argc_argv enabled this yields remote code execution.
Articles & Coverage 1
Executive ViewAI
A critical unauthenticated PHP object injection vulnerability in the Gravity Forms WordPress plugin (all versions up to 3.1.2) allows remote attackers to inject serialized payloads via a misconfigured Post Custom Field. Successful exploitation requires a non-default form setup and a gadget chain from another plugin or theme, but could enable remote code execution. Leadership should prioritize patching because any site using Gravity Forms with such configurations is at risk, and no vendor fix is currently available.
No vendor-released patch identified at time of analysis. Interim mitigations include restricting or disabling List-type Post Custom Fields in Gravity Forms, especially those mapped to _wp_page_template; deploying a WAF to block serialized payloads in POST requests; removing or updating plugins/themes that provide known gadget chains; and enabling strict input validation and monitoring for exploitation indicators.
Threat Intelligence Overview
How this decision was reached
The engine reads each signal below and applies a fixed list of rules from top to bottom. The first rule that matches sets the recommended action – like a statement, every line is shown.
What every action level means
SSVC AssessmentENISA
Priority Score
Attack Technique
Insecure deserialization occurs when an application converts serialized data (a stream of bytes representing an object's state) back into a living object without proper validation.
Remote Code Execution represents the critical moment when an attacker successfully runs arbitrary code on a target system without physical access.
More in Gravity Forms
View allUnauthenticated arbitrary file upload in the Gravity Forms WordPress plugin through version 3.1.0.4 can lead to remote c
The Clockwork SMS clockwork-test-message.php component has XSS via a crafted "to" parameter in a clockwork-test-message
The Gravity Forms WordPress plugin before 2.7.5 does not escape generated URLs before outputting them in attributes, lea
Deserialization of Untrusted Data vulnerability in Rocketgenius Inc. Rated high severity (CVSS 8.3), this vulnerability
Arbitrary file upload in Gravity Forms for WordPress (all versions ≤ 3.0.2) allows unauthenticated attackers to write PH
Arbitrary file disclosure in the Gravity Forms WordPress plugin (all versions through 2.10.4) lets unauthenticated attac
Stored cross-site scripting in the Gravity Forms WordPress plugin through 3.1.2 allows unauthenticated form submitters t
Stored cross-site scripting in the Gravity Forms plugin for WordPress, affecting all versions up to and including 3.1.1,
Stored Cross-Site Scripting in the Gravity Forms WordPress plugin (all versions ≤2.10.5) permits unauthenticated attacke
Stored cross-site scripting (XSS) in Gravity Forms WordPress plugin versions ≤2.10.0 allows remote unauthenticated attac
Stored Cross-Site Scripting in Gravity Forms plugin for WordPress through version 2.10.0 allows unauthenticated remote a
Stored XSS in Gravity Forms for WordPress ≤2.10.0 allows unauthenticated remote attackers to inject malicious JavaScript
EUVD-2026-113740
GHSA-635p-78xg-j6w3
NVD
CVE.org
EPSS
Vulnrichment
Exploit-DB