CVEReports
CVEReports

Automated vulnerability intelligence platform. Comprehensive reports for high-severity CVEs generated by AI.

Product

  • Home
  • Sitemap
  • RSS Feed

Company

  • About
  • Contact
  • Privacy Policy
  • Terms of Service

© 2026 CVEReports. All rights reserved.

Made with love by Amit Schendel & Alon Barad



CVE-2026-88989

CVE-2026-88989: Authorization Bypass in Silverstripe Framework GridFieldDetailForm

Amit Schendel
Amit Schendel
Senior Security Researcher

Nov 17, 2026·10 min read·1 visit

Executive Summary (TL;DR)

An authorization bypass in Silverstripe Framework (< 6.2.13) allows authenticated CMS users without model creation permissions to create new database records by sending direct POST requests to the GridFieldDetailForm save endpoint. Upgrade to version 6.2.13 to remediate the flaw.

CVE-2026-88989 (tracked as GHSA-3qh3-54qg-gpq3) is a missing authorization vulnerability (CWE-862) in the Silverstripe Framework affecting versions prior to 6.2.13. The flaw exists within the GridFieldDetailForm_ItemRequest request handler, which orchestrates record creation and editing workflows inside the Silverstripe CMS backend. Specifically, the server-side persistence method saveFormIntoRecord() fails to verify whether an authenticated user possesses the necessary creation permissions (canCreate) when processing an unpersisted DataObject record. Consequently, a low-privileged CMS user who has permission to access a GridField interface and edit existing records can bypass role-based creation restrictions. By sending a crafted HTTP POST request directly to the item/new endpoint with the action_doSave parameter, the user can instantiate and persist unauthorized database records. The vulnerability is rated Medium severity with a CVSS v3.1 base score of 4.3 and is remediated in Silverstripe Framework version 6.2.13.

Vulnerability Overview

Silverstripe Framework (silverstripe/silverstripe-framework) is the core PHP web application framework underlying the Silverstripe Content Management System (CMS). Within the administrative backend, the GridField component serves as the primary user interface control for viewing, managing, and editing tabular collections of DataObject models. Detailed record manipulation—such as editing individual model attributes or creating new entries—is delegated to the GridFieldDetailForm component and its associated request handler, GridFieldDetailForm_ItemRequest.

In versions prior to 6.2.13, GridFieldDetailForm_ItemRequest contains a missing authorization vulnerability classified under CWE-862 (Missing Authorization). When a CMS user interacts with a GridField, the framework relies on model-level permission methods (canView(), canEdit(), canDelete(), and canCreate()) to enforce access control policies. While the user interface layer hides creation controls and renders form fields as read-only when canCreate() evaluates to false, the backend persistence routine failed to enforce this restriction during form submission processing.

Specifically, when an HTTP POST request triggers the doSave action for a new record, execution flows into GridFieldDetailForm_ItemRequest::saveFormIntoRecord(). This method checked whether the user could edit the form context but omitted an explicit verification of $this->record->canCreate() for unpersisted records (where $this->record->ID is zero or null). This discrepancy between presentation-layer restrictions and controller-layer enforcement exposes an attack surface accessible to any authenticated user with CMS access.

An authenticated attacker who possesses permissions to view a GridField and edit existing records can exploit this oversight by issuing a direct HTTP POST request to the item/new/ItemEditForm endpoint. The server processes the request, populates a new DataObject instance with the attacker-supplied parameters, and commits the record to the database, violating the application's data integrity constraints.

Root Cause Analysis

To understand the root cause of CVE-2026-88989, it is necessary to examine how Silverstripe Framework handles routing and request dispatching within GridField. When a user interacts with a specific item in a GridField, the request is routed to GridFieldDetailForm_ItemRequest via a URL pattern ending in /item/<ID>. When creating a new record, the URL segment <ID> is replaced with the literal string new (.../item/new). During initialization, the request handler resolves the new identifier by instantiating an in-memory, unpersisted DataObject of the target model class where $this->record->ID is 0.

In the standard Silverstripe permission architecture, restricting record creation while allowing record editing is a common access control pattern. For example, a site administrator may configure a DataObject so that content authors can modify existing configuration items (canEdit() returns true), while only administrators can provision new items (canCreate() returns false). At the UI layer, GridFieldAddNewButton checks canCreate() before rendering the creation button. Furthermore, if a user manually navigates to the /item/new URL without creation privileges, ItemEditForm() transforms the form fields into a read-only state.

However, the form action handler in GridFieldDetailForm_ItemRequest did not mirror these restrictions during POST processing. When a form submission includes the action_doSave parameter, the framework invokes doSave($data, $form), which subsequently calls the protected helper method saveFormIntoRecord($data, $form). Prior to version 6.2.13, saveFormIntoRecord() immediately retrieved the underlying DataList from the GridField, validated the object class name, copied the submitted form payload into the $this->record instance, and executed $this->record->write().

Because the form rendering process and the form action execution process occur across independent HTTP requests or within separate execution stages, relying on read-only form transformation is insufficient if the action handler does not validate permissions prior to state mutation. By submitting raw POST parameters alongside a valid CSRF token (SecurityID) directly to the form endpoint, an attacker bypasses the UI controls entirely and triggers database persistence on the unpersisted $this->record object.

Code Analysis

The vulnerability was resolved in commit 693c948bae13dd2a854489baa575123ca3e60155 (Pull Request #12043). The patch modifies src/Forms/GridField/GridFieldDetailForm_ItemRequest.php to introduce an explicit authorization gate at the entry point of saveFormIntoRecord(), and adds a corresponding localized error string in lang/en.yml.

File: lang/en.yml
@@ -174,6 +174,7 @@ en:
     Save: Save
     Saved: 'Saved {name} {link}'
   SilverStripe\Forms\GridField\GridFieldDetailForm_ItemRequest:
+    CreatePermissionsFailure: 'It seems you don''t have the necessary permissions to create "{ObjectTitle}"'
     EditPermissionsFailure: 'It seems you don''t have the necessary permissions to edit "{ObjectTitle}"'
     NEW: 'Add new record'
     NEXT: 'Go to next record'
 
File: src/Forms/GridField/GridFieldDetailForm_ItemRequest.php
@@ -821,6 +821,17 @@ public function httpError($errorCode, $errorMessage = null)
      */
     protected function saveFormIntoRecord($data, $form)
     {
+        // Check if the record is unpersisted (new) and verify creation permissions
+        if (!$this->record->ID
+            && (!$this->record->hasMethod('canCreate') || !$this->record->canCreate(null, $this->getCreateContext()))
+        ) {
+            // Abort execution with HTTP 403 Forbidden if canCreate() fails
+            $this->httpError(403, _t(
+                __CLASS__ . '.CreatePermissionsFailure',
+                'It seems you don\'t have the necessary permissions to create "{ObjectTitle}"',
+                ['ObjectTitle' => $this->getModelName()]
+            ));
+            return null;
+        }
+
         $list = $this->gridField->getList();
 
         // Check object matches the correct classname

The added conditional block evaluates three specific conditions before allowing execution to proceed:

  1. Unpersisted Record Detection (!$this->record->ID): In Silverstripe's ORM, a DataObject that has not yet been written to the database has an ID property of 0 (or null). If $this->record->ID is truthy, the operation is an update to an existing record rather than a creation event, and this specific check is bypassed in favor of edit permission checks.
  2. Method Existence Verification (!$this->record->hasMethod('canCreate')): In adherence to fail-safe defaults, if the target object does not implement a canCreate method at all, the condition evaluates to true (unauthorized), preventing persistence.
  3. Context-Aware Permission Evaluation (!$this->record->canCreate(null, $this->getCreateContext())): The framework calls canCreate() passing null for the member parameter (which defaults to evaluating the currently authenticated Security::getCurrentUser()) and passes $this->getCreateContext() to supply relational context if the GridField is managing a has_many or many_many relationship.

> [!NOTE] > In Silverstripe Framework, invoking $this->httpError(403, ...) throws an HTTPResponse_Exception, which terminates normal controller execution and returns an HTTP 403 Forbidden response to the client. The return null; statement serves as a fallback in case custom error handling overrides the exception behavior.

With respect to fix completeness, placing the check inside saveFormIntoRecord() ensures that both standard save operations (doSave) and any custom controller actions that delegate persistence to saveFormIntoRecord() are protected. Because $this->getCreateContext() is passed to canCreate(), custom permission logic that depends on parent relationships in nested GridField instances is also accurately evaluated.

Exploitation

Exploiting CVE-2026-88989 requires low-level privileges (PR:L), specifically an active authenticated session within the Silverstripe CMS admin interface (such as a user possessing the CMS_ACCESS_LeftAndMain permission or access to a specific ModelAdmin controller). No specialized exploit tooling or complex timing conditions are necessary; standard HTTP client utilities or browser developer tools are sufficient.

To execute the attack, the adversary first authenticates to the CMS and identifies a GridField managing a restricted DataObject model where creation is disabled for their role. Even when the GridFieldAddNewButton is hidden from the interface, the routing structure of GridFieldDetailForm remains predictable. The attacker can navigate to or construct the URL for the new item endpoint by appending /item/new to the GridField field path, or by inspecting the URL structure when editing an existing item (e.g., replacing /item/42 with /item/new).

Once the target endpoint is identified, the attacker retrieves a valid Silverstripe CSRF token (SecurityID) from any authenticated CMS form or via a GET request to the /item/new endpoint. The attacker then transmits a crafted HTTP POST request directly to the ItemEditForm action handler:

POST /admin/my-model-admin/MyModel/EditForm/field/MyModel/item/new/ItemEditForm HTTP/1.1
Host: target.example.com
Cookie: PHPSESSID=a1b2c3d4e5f6g7h8i9j0
Content-Type: application/x-www-form-urlencoded
Content-Length: 89
 
Title=Unauthorized+Record&Description=Injected+Data&action_doSave=1&SecurityID=9f8e7d6c5b4a3210

The vendor's functional test suite (tests/php/Forms/GridField/GridFieldDetailFormCreatePermissionTest.php), committed alongside the patch in 693c948bae13dd2a854489baa575123ca3e60155, demonstrates the exact reproduction mechanics programmatically:

#[DataProvider('provideDoSaveNewRecord')]
public function testDoSaveNewRecord(string $permission, int $expectedStatusCode, int $expectedNumCreated): void
{
    // Authenticate as a user with CMS access, but lacking CreateRestrictedObject::CREATE_PERMISSION
    $this->logInWithPermission($permission);
    
    // Retrieve the form action URL for the 'new' item endpoint
    $formUrl = $this->getItemEditFormUrl('new');
    $title = 'Created via a crafted doSave submission';
    $numRecordsBefore = CreateRestrictedObject::get()->count();
 
    // Submit the crafted POST request with action_doSave
    $response = $this->post($formUrl, [
        'Title' => $title, 
        'action_doSave' => 1
    ]);
 
    // Verify whether the record was persisted and check the HTTP status code
    $numCreated = CreateRestrictedObject::get()->count() - $numRecordsBefore;
    $this->assertSame($expectedNumCreated, $numCreated);
    $this->assertSame($expectedStatusCode, $response->getStatusCode());
}

On unpatched versions (< 6.2.13), the server responds with 200 OK (or a 302 Found redirect to the newly assigned record ID, such as /item/43/edit), and $numCreated equals 1. On patched versions (>= 6.2.13), the server halts execution prior to database insertion, returns 403 Forbidden, and $numCreated remains 0.

Impact Assessment

CVE-2026-88989 is assigned a CVSS v3.1 base score of 4.3 (Medium) with the vector string CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:N/I:L/A:N. The Attack Vector is Network (AV:N) and Attack Complexity is Low (AC:L), reflecting that the CMS administrative interface is accessible over standard HTTP/HTTPS connections and requires no complex preparation to exploit. Privileges Required is Low (PR:L) because the attacker must possess valid credentials for a low-privileged CMS backend account, and User Interaction is None (UI:N).

The primary security impact is confined to Integrity (I:L), with no direct impact to Confidentiality (C:N) or Availability (A:N). The Scope remains Unchanged (S:U) because both the vulnerable component (the Silverstripe controller layer) and the impacted resource (the application database) reside within the same security authority.

In practical deployment scenarios, the severity of this authorization bypass depends on the nature of the DataObject models exposed via GridField interfaces to non-administrative users:

  • Content and Data Pollution: Content editors restricted to modifying specific existing records can inject arbitrary new records into collections, corrupting application state or publishing unauthorized entries.
  • Business Logic Bypass: Applications that rely on canCreate() to enforce singleton patterns (where only one configuration record should exist in a table) or quota limits (where canCreate() returns false once a record count threshold is reached) can have their constraints bypassed.
  • Secondary Privilege Escalation: If a custom GridField exposes security-sensitive models—such as workflow approval rules, API tokens, or role mappings—where low-privileged users are permitted to view or edit non-sensitive metadata on existing entries but forbidden from provisioning new entries, an attacker can create new functional objects to elevate their access.

As of the latest threat intelligence data, CVE-2026-88989 is not listed in the CISA Known Exploited Vulnerabilities (KEV) catalog, and no public exploitation in the wild has been reported.

Remediation & Mitigation

The definitive remediation for CVE-2026-88989 is to upgrade silverstripe/silverstripe-framework to version 6.2.13 or later. Silverstripe installations are managed via Composer, and administrators should update the framework package along with its dependencies:

composer update silverstripe/silverstripe-framework --with-dependencies

After running the update command, verify that the installed package version meets or exceeds 6.2.13:

composer show silverstripe/silverstripe-framework

In environments where an immediate upgrade cannot be performed, developers can implement a temporary defense-in-depth workaround at the model layer. Specifically, overriding the onBeforeWrite() lifecycle hook within restricted DataObject classes allows the model itself to enforce canCreate() prior to database insertion:

use SilverStripe\ORM\DataObject;
use SilverStripe\Security\PermissionFailureException;
 
class RestrictedRecord extends DataObject
{
    protected function onBeforeWrite()
    {
        parent::onBeforeWrite();
 
        // Enforce creation permissions at the ORM layer if the record is new
        if (!$this->isInDB() && !$this->canCreate()) {
            throw new PermissionFailureException('Creation of this record is not permitted.');
        }
    }
}

> [!WARNING] > Implementing checks inside onBeforeWrite() can disrupt legitimate background tasks, CLI scripts (sake), or system-level automated routines that instantiate and write records without an active user session. Ensure that system contexts are accounted for before deploying ORM-level hooks in production.

Additionally, security teams operating vulnerable instances should audit database tables and HTTP access logs for evidence of prior exploitation. In web server logs, look for HTTP POST requests targeting URLs matching the pattern */item/new/ItemEditForm that returned HTTP status codes 200 or 302 when initiated by non-administrative user sessions.

Official Patches

SilverstripeGitHub Security Advisory GHSA-3qh3-54qg-gpq3
SilverstripeOfficial Silverstripe Security Release Advisory for CVE-2026-88989
SilverstripeSilverstripe Framework 6.2.13 Release Tag
SilverstripePull Request #12043 containing the security patch and unit tests

Fix Analysis (1)

Technical Appendix

CVSS Score
4.3/ 10
CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:N/I:L/A:N

Affected Systems

Silverstripe Framework (silverstripe/silverstripe-framework)Silverstripe CMS

Affected Versions Detail

Product
Affected Versions
Fixed Version
silverstripe/silverstripe-framework
Silverstripe Ltd.
< 6.2.136.2.13
AttributeDetail
Vulnerability IDCVE-2026-88989 / GHSA-3qh3-54qg-gpq3
Weakness ClassCWE-862: Missing Authorization
CVSS v3.1 Score4.3 (Medium) - CVSS:3.1/AV:N/AC:L/PR:L/UI:N/S:U/C:N/I:L/A:N
Affected ComponentGridFieldDetailForm_ItemRequest::saveFormIntoRecord()
Affected Versionssilverstripe/silverstripe-framework < 6.2.13
Patched Versionsilverstripe/silverstripe-framework 6.2.13
ImpactUnauthorized creation of DataObject records by low-privileged CMS users
Exploit StatusPoC available in vendor test suite; Not listed in CISA KEV

MITRE ATT&CK Mapping

T1068Exploitation for Privilege Escalation
Privilege Escalation
CWE-862
Missing Authorization

The software does not perform an authorization check when an actor attempts to access a resource or perform an action.

Known Exploits & Detection

GitHubOfficial functional regression test (GridFieldDetailFormCreatePermissionTest.php) demonstrating the authorization bypass via a direct POST request with action_doSave=1.

Vulnerability Timeline

Security fix committed by Steve Boyd (commit 693c948bae13dd2a854489baa575123ca3e60155, PR #12043).
2026-10-28
Silverstripe Framework 6.2.13 released containing the patch.
2026-11-16
GitHub Security Advisory GHSA-3qh3-54qg-gpq3 and CVE-2026-88989 published to CVE.org and NVD.
2026-11-16
OSV database record updated with affected version ranges.
2026-11-17

References & Sources

  • [1]GitHub Security Advisory: GHSA-3qh3-54qg-gpq3
  • [2]Silverstripe Framework Pull Request #12043
  • [3]Patch Commit 693c948bae13dd2a854489baa575123ca3e60155
  • [4]Silverstripe Framework Release 6.2.13
  • [5]Silverstripe Security Release Advisory: CVE-2026-88989
  • [6]National Vulnerability Database (NVD): CVE-2026-88989
  • [7]CVE.org Record: CVE-2026-88989
  • [8]CVEListV5 JSON Record: CVE-2026-88989

Attack Flow Diagram

Press enter or space to select a node. You can then use the arrow keys to move the node around. Press delete to remove it and escape to cancel.
Press enter or space to select an edge. You can then press delete to remove it or escape to cancel.

More Reports

•about 1 hour ago•CVE-2026-91112
6.8

CVE-2026-91112: Privilege Escalation via CMS_ACCESS_SecurityAdmin in Silverstripe Framework

Silverstripe Framework prior to version 6.2.13 contains an improper privilege management vulnerability (CWE-269) within the Group authorization and validation logic. A delegated administrator possessing the CMS_ACCESS_SecurityAdmin permission, but lacking full ADMIN privileges, can edit or reparent groups that acquire administrative capabilities indirectly via permission roles or ancestor inheritance. By adding their own account to such a group or moving a controlled group underneath a role-privileged parent, the user escalates to full administrative access across the CMS.

Amit Schendel
Amit Schendel
3 views•9 min read
•about 2 hours ago•CVE-2026-91113
4.3

CVE-2026-91113: Missing Authorization and Arbitrary Record Type Conversion in Silverstripe Framework GridFieldDetailForm

A missing authorization and type validation vulnerability in Silverstripe Framework prior to version 6.2.13 allows authenticated CMS users to convert database records into arbitrary DataObject classes via user-controlled ClassName parameters in GridField detail forms.

Alon Barad
Alon Barad
4 views•9 min read
•about 3 hours ago•CVE-2026-91115
8.8

CVE-2026-91115: Remote Code Execution in Silverstripe Framework via i18nTextCollectorTask

CVE-2026-91115 (GHSA-c94f-87xg-65wf) is an unsafe reflection vulnerability in the Silverstripe Framework affecting versions 6.0.0 prior to 6.2.13. The built-in development task i18nTextCollectorTask passes the user-supplied 'writer' parameter directly to Silverstripe's dependency injection container (Injector::inst()->get()) without verifying that the requested class implements the expected Writer interface. Because the dependency injector supports instantiating arbitrary classes with attacker-supplied constructor arguments, and because nested task URLs bypassed interactive confirmation middleware, an attacker can achieve remote code execution via unauthenticated requests on development instances or via Cross-Site Request Forgery (CSRF) against authenticated administrators on production instances.

Amit Schendel
Amit Schendel
5 views•8 min read
•about 4 hours ago•CVE-2026-129237
5.4

CVE-2026-129237: Partial Path Traversal (Zip Slip) in qbee-agent Tar Extractor

CVE-2026-129237 is a partial path traversal (Zip Slip) vulnerability in qbee-agent, the device agent for the qbee.io IoT device management platform. Prior to version 2026.41, the tar archive extraction routine in app/utils/tar.go used strings.HasPrefix without enforcing a directory separator boundary. When the Docker Compose bundle configuration has UseContext enabled, an authenticated user with delegated configuration or file management privileges can supply a crafted tar archive containing sibling-prefix traversal sequences, allowing directory creation and file writes into adjacent sibling directories outside the intended extraction root.

Alon Barad
Alon Barad
4 views•11 min read
•about 5 hours ago•CVE-2026-128118
7.5

CVE-2026-128118: Server-Only Module Guard Bypass and Secret Exposure in SvelteKit

CVE-2026-128118 (GHSA-m9j8-jcmv-hp69) is an information disclosure vulnerability affecting the SvelteKit framework (@sveltejs/kit) from version 3.0.0 through 3.1.0. A design flaw in the build-time Vite module guard plugin (plugin_guard) failed to register src/params.js as a client entry point and implemented a fail-open validation model. Consequently, server-only modules and private environment variables imported directly or dynamically within parameter matchers were compiled into publicly accessible client-side JavaScript bundles without triggering a build error.

Amit Schendel
Amit Schendel
4 views•10 min read
•about 6 hours ago•CVE-2026-128071
6.5

CVE-2026-128071: Route-Rule Authorization Bypass via Encoded Slashes in Nuxt

CVE-2026-128071 is a route-rule authorization bypass and security policy circumvention vulnerability in the Nuxt web framework, affecting `nuxt`, `@nuxt/nitro-server`, and `@nuxt/vite-server` prior to version 4.6.4. Serving as an incomplete fix for GHSA-6gq8-jgmh-3ffp, the flaw arises from an interpretation conflict between Nuxt's route-rule matching logic and Vue Router's catch-all route parameter decoding. When processing an incoming HTTP request containing percent-encoded forward slashes (`%2F` or `%2f`), the route-rule evaluation engine preserves the encoded sequence as a single path segment, failing to match prefix-based rules such as `/admin/**`. However, when the request is subsequently dispatched to a catch-all page route (`app/pages/[...slug].vue`) or a multi-segment parameter handler, the parameters are URL-decoded into literal slash delimiters. This discrepancy allows unauthenticated remote attackers to bypass route-level redirects, authentication middleware (`appMiddleware`), security headers, proxy configurations, and rendering constraints (`ssr: false`, `noScripts`), while the catch-all page resolves and renders the protected resource.

Amit Schendel
Amit Schendel
5 views•11 min read