Skip to main content

Gravity Forms CVE-2026-103039

| EUVDEUVD-2026-113740 CRITICAL
Deserialization of Untrusted Data (CWE-502)
2026-10-30 Wordfence GHSA-635p-78xg-j6w3
9.8
CVSS 3.1 · Vendor: Wordfence
View

Attack ChainAIDerived

Hypothetical attack flow derived from CVE metadata – not a confirmed exploit chain

  1. Access
    Find form with List post-custom-field + content template
  2. Delivery
    Submit crafted serialized PHP object in row
  3. Exploit
    Reach unrestricted maybe_unserialize()
  4. Execution
    Inject PHP object into post meta
  5. Persist
    Trigger WP_Theme::__toString via _wp_page_template
  6. Impact
    Execute 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.

Act Now Prioritize within 24-48h. Why: CRITICAL severity.
No patch listed yet 0.5% exploitation probability (EPSS)

Get an e-mail when this CVE is exploited, patched or re-scored. Free account.

Alert me

AnalysisAIv1 – 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

Gravity Forms 0 ≤3.1.2

Affected Packages

euvd gravity_forms no fix

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

Vendor (Wordfence) PRIMARY 9.8 CRITICAL
AV:N/AC:L/PR:N/UI:N/S:U/C:H/I:H/A:H
vuln.today AI 8.1 HIGH

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.

3.1 AV:N/AC:H/PR:N/UI:N/S:U/C:H/I:H/A:H
4.0 AV:N/AC:L/AT:P/PR:N/UI:N/VC:H/VI:H/VA:H/SC:N/SI:N/SA:N

Primary rating from Vendor (Wordfence).

CVSS VectorVendor: Wordfence

Attack Vector
Network
Attack Complexity
Low
Privileges Required
None
User Interaction
None
Scope
Unchanged
Confidentiality
High
Integrity
High
Availability
High

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.

Executive ViewAI

Why It Matters

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.

Business Impact: Severe
Compensating Controls

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

EPSS Score
0.5%
Top 57% exploitable
Prevalence
High
one of the most widely deployed premium WordPress form plugins
Social Media
5
Sightings
Data Quality
4 sources
Confidence: Medium

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.

SignalValue
Severity CRITICAL
CISA KEV No
Public POC No
EPSS 0.5%
Patch available No
Active threat No
Deciding rule
CRITICAL severity
What every action level means
Emergency Immediate action required. Criteria: CRITICAL + in CISA KEV (actively exploited) without patch, OR CRITICAL + EPSS > 30% without patch, OR CRITICAL + active threat signals without patch.
Act Now Prioritize within 24-48h. Criteria: in KEV with patch available, OR CRITICAL + public POC, OR HIGH + EPSS > 10%, OR CRITICAL + active threat, OR any CRITICAL severity.
This Week Schedule remediation this week. Criteria: HIGH severity (CVSS 7.0-8.9). Patch within normal change window.
This Month Plan within 30 days. Criteria: MEDIUM severity (CVSS 4.0-6.9), lower exploitation probability. Include in regular patch cycle.
Monitor Track and reassess. Criteria: LOW severity (CVSS 0.1-3.9), minimal exploitation risk. No immediate action needed.

SSVC AssessmentENISA

SSVC Decision
Out-of-Cycle
Exploitation
None
System Exposure· derived
Open
Automatable
Yes
Human Impact
Very High
Technical Impact
Total

Priority Score

50
Low Medium High Critical
KEV: 0
EPSS: +1
CVSS: +49
PoC: 0
Weaponized: 0
Threat intel: 0
Gov advisory: 0

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.

CVE-2026-84434 CRITICAL POC
9.8 Sep 19

Unauthenticated arbitrary file upload in the Gravity Forms WordPress plugin through version 3.1.0.4 can lead to remote c

CVE-2017-17780 MEDIUM POC
6.1 Dec 20

The Clockwork SMS clockwork-test-message.php component has XSS via a crafted "to" parameter in a clockwork-test-message

CVE-2023-2701 MEDIUM POC
6.1 Jul 17

The Gravity Forms WordPress plugin before 2.7.5 does not escape generated URLs before outputting them in attributes, lea

CVE-2023-28782 HIGH
8.3 Dec 20

Deserialization of Untrusted Data vulnerability in Rocketgenius Inc. Rated high severity (CVSS 8.3), this vulnerability

CVE-2026-19513 HIGH
8.1 Sep 01

Arbitrary file upload in Gravity Forms for WordPress (all versions ≤ 3.0.2) allows unauthenticated attackers to write PH

CVE-2026-12997 HIGH
7.5 Jul 15

Arbitrary file disclosure in the Gravity Forms WordPress plugin (all versions through 2.10.4) lets unauthenticated attac

CVE-2026-97645 HIGH
7.2 Oct 30

Stored cross-site scripting in the Gravity Forms WordPress plugin through 3.1.2 allows unauthenticated form submitters t

CVE-2026-90437 HIGH
7.2 Oct 30

Stored cross-site scripting in the Gravity Forms plugin for WordPress, affecting all versions up to and including 3.1.1,

CVE-2026-16649 HIGH
7.2 Sep 05

Stored Cross-Site Scripting in the Gravity Forms WordPress plugin (all versions ≤2.10.5) permits unauthenticated attacke

CVE-2026-5110 HIGH
7.2 May 02

Stored cross-site scripting (XSS) in Gravity Forms WordPress plugin versions ≤2.10.0 allows remote unauthenticated attac

CVE-2026-5111 HIGH
7.2 May 02

Stored Cross-Site Scripting in Gravity Forms plugin for WordPress through version 2.10.0 allows unauthenticated remote a

CVE-2026-5109 HIGH
7.2 May 02

Stored XSS in Gravity Forms for WordPress ≤2.10.0 allows unauthenticated remote attackers to inject malicious JavaScript

This site uses cookies essential for authentication and security. No tracking or analytics cookies are used. Privacy Policy